private void numericUpDown7_ValueChanged(object sender, EventArgs e)
{
if (_skipSet)
{
return;
}
System.Drawing.Color asRGB = System.Drawing.Color.FromArgb((int)numericUpDown5.Value, (int)numericUpDown6.Value,
(int)numericUpDown7.Value);
HSL hsl = ColorSpaceHelper.RGBtoHSL(asRGB);
_skipSet = true;
numericUpDown1.Value = (int)hsl.Hue;
numericUpDown2.Value = (int)(hsl.Saturation * 240.0f);
numericUpDown3.Value = (int)(hsl.Luminance * 240.0f);
colorSquare1.CurrentHue = (int)numericUpDown1.Value;
colorSquare1.CurrentSat = (int)numericUpDown2.Value;
saturationSlider1.CurrentLum = (int)numericUpDown3.Value;
saturationSlider1.Color = new HSL(colorSquare1.CurrentHue, (double)colorSquare1.CurrentSat / 240.0f, 0);
panel1.BackColor = asRGB;
_skipSet = false;
}
public override Color BlendColor(Color l, Color r)
{
bool ctrlIng = (Control.ModifierKeys & Keys.Shift) != 0;
bool switchTools = (!Editor.MainForm.DarkenLightenOptions.Inverted && ctrlIng) ||
(Editor.MainForm.DarkenLightenOptions.Inverted && !ctrlIng);
HSL hsl = ColorSpaceHelper.RGBtoHSL(r);
float mod = l.A / 255.0f;
if (switchTools)
{
hsl.Luminance -= (GlobalSettings.DarkenLightenExposure * mod) / 5.0f;
}
else
{
hsl.Luminance += (GlobalSettings.DarkenLightenExposure * mod) / 5.0f;
}
if (hsl.Luminance < 0)
{
hsl.Luminance = 0;
}
if (hsl.Luminance > 1)
{
hsl.Luminance = 1;
}
return(Color.FromArgb(r.A, ColorSpaceHelper.HSLtoColor(hsl)));
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
var borderThing = new Rectangle(0, 8, Width - 8, Height - 16);
HSL half = Color;
half.Luminance = 0.5f;
ColorSpaceRenderer.GenerateColorSlider(e.Graphics, ColorSpaceHelper.HSLtoRGB(half).ToColor(), borderThing);
ControlPaint.DrawBorder3D(e.Graphics, borderThing, Border3DStyle.SunkenOuter);
float inc = (Height - 18) / 240.0f;
float invLum = (240 - _curLum);
e.Graphics.FillPolygon(Brushes.Black,
new[]
{
new Point(Width - 7, 6 + (int)(invLum * inc) + 2),
new Point(Width - 1, 12 + (int)(invLum * inc) + 2),
new Point(Width - 1, 0 + (int)(invLum * inc) + 2),
}
);
}
public void ApplyChromaKey(KalikoImage image)
{
unsafe {
var bitmapData = image.LockBits();
var bytesPerPixel = Image.GetPixelFormatSize(bitmapData.PixelFormat) / 8;
var height = bitmapData.Height;
var widthInBytes = bitmapData.Width * bytesPerPixel;
var startOffset = (byte *)bitmapData.Scan0;
var keyHsb = ColorSpaceHelper.RGBtoHSB(KeyColor);
Parallel.For(0, height, y => {
var currentLine = startOffset + (y * bitmapData.Stride);
for (var x = 0; x < widthInBytes; x = x + bytesPerPixel)
{
var red = currentLine[x];
var green = currentLine[x + 1];
var blue = currentLine[x + 2];
var hsb = ColorSpaceHelper.RGBtoHSB(red, green, blue);
if (Abs(hsb.Hue, keyHsb.Hue) < ToleranceHue && Abs(hsb.Saturation, keyHsb.Saturation) < ToleranceSaturnation && Abs(hsb.Brightness, keyHsb.Brightness) < ToleranceBrightness)
{
currentLine[x + 3] = 0;
}
}
});
image.UnlockBits(bitmapData);
}
}
public void ApplyChromaKey(KalikoImage image)
{
var pixels = image.IntArray;
var keyHsb = ColorSpaceHelper.RGBtoHSB(KeyColor);
for (int i = 0; i < pixels.Length; i++)
{
int rgb = pixels[i];
int red = (rgb >> 16) & 0xff;
int green = (rgb >> 8) & 0xff;
int blue = rgb & 0xff;
HSB hsb = ColorSpaceHelper.RGBtoHSB(red, green, blue);
if (Math.Abs(hsb.Hue - keyHsb.Hue) < ToleranceHue && Math.Abs(hsb.Saturation - keyHsb.Saturation) < ToleranceSaturnation && Math.Abs(hsb.Brightness - keyHsb.Brightness) < ToleranceBrightness)
{
pixels[i] = rgb & 0xffffff;
}
else
{
pixels[i] = rgb;
}
}
image.IntArray = pixels;
}
private CIELab MapRawToCieLab(string rawData, string illuminantObserver)
{
var spectrumToXyzConverter = new SpectrumToXYZConverter();
var xyzToLabConverter = new ColorSpaceHelper(spectrumToXyzConverter);
var spectrumToLabConverter = new SpectrumToLabConverter(spectrumToXyzConverter, xyzToLabConverter);
var coordinateMapper = new ColorCalculation.CoordinateMapper(spectrumToLabConverter);
return(coordinateMapper.MapRawToCieLab(rawData, illuminantObserver));
}
internal void SetupFromBrush(XRadialGradientBrush brush, XGraphicsPdfRenderer renderer)
{
if (brush == null)
{
throw new ArgumentNullException("brush");
}
PdfColorMode colorMode = _document.Options.ColorMode;
XColor color1 = ColorSpaceHelper.EnsureColorMode(colorMode, brush._color1);
XColor color2 = ColorSpaceHelper.EnsureColorMode(colorMode, brush._color2);
PdfDictionary function = new PdfDictionary();
Elements[Keys.ShadingType] = new PdfInteger(3);
if (colorMode != PdfColorMode.Cmyk)
{
Elements[Keys.ColorSpace] = new PdfName("/DeviceRGB");
}
else
{
Elements[Keys.ColorSpace] = new PdfName("/DeviceCMYK");
}
XPoint p1 = renderer.WorldToView(brush._center1);
XPoint p2 = renderer.WorldToView(brush._center2);
var rv1 = renderer.WorldToView(new XPoint(brush._r1 + brush._center1.X, brush._center1.Y));
var rv2 = renderer.WorldToView(new XPoint(brush._r2 + brush._center2.X, brush._center2.Y));
var dx1 = rv1.X - p1.X;
var dy1 = rv1.Y - p1.Y;
var dx2 = rv2.X - p2.X;
var dy2 = rv2.Y - p2.Y;
var r1 = Math.Sqrt(dx1 * dx1 + dy1 * dy1);
var r2 = Math.Sqrt(dx2 * dx2 + dy2 * dy2);
const string format = Config.SignificantFigures3;
Elements[Keys.Coords] = new PdfLiteral("[{0:" + format + "} {1:" + format + "} {2:" + format + "} {3:" + format + "} {4:" + format + "} {5:" + format + "}]", p1.X, p1.Y, r1, p2.X, p2.Y, r2);
//Elements[Keys.Background] = new PdfRawItem("[0 1 1]");
//Elements[Keys.Domain] =
Elements[Keys.Function] = function;
//Elements[Keys.Extend] = new PdfRawItem("[true true]");
string clr1 = "[" + PdfEncoders.ToString(color1, colorMode, true) + "]";
string clr2 = "[" + PdfEncoders.ToString(color2, colorMode, true) + "]";
function.Elements["/FunctionType"] = new PdfInteger(2);
function.Elements["/C0"] = new PdfLiteral(clr1);
function.Elements["/C1"] = new PdfLiteral(clr2);
function.Elements["/Domain"] = new PdfLiteral("[0 1]");
function.Elements["/N"] = new PdfInteger(1);
}
public void Parse()
{
Assert.Equal(ColorSpace.sRGB, ColorSpaceHelper.Parse("sRgb"));
Assert.Equal(ColorSpace.sRGB, ColorSpaceHelper.Parse("sRGB"));
Assert.Equal(ColorSpace.AdobeRGB, ColorSpaceHelper.Parse("AdobeRgb"));
Assert.Equal(ColorSpace.RGB, ColorSpaceHelper.Parse("RGB"));
Assert.Equal(ColorSpace.RGB, ColorSpaceHelper.Parse("rgb"));
Assert.Equal(ColorSpace.CMYK, ColorSpaceHelper.Parse("cmyk"));
Assert.Equal(ColorSpace.Gray, ColorSpaceHelper.Parse("grayscale"));
}
private void numericUpDown3_ValueChanged(object sender, EventArgs e)
{
if (_skipSet)
{
return;
}
saturationSlider1.CurrentLum = (int)numericUpDown3.Value;
saturationSlider1.Color = new HSL(colorSquare1.CurrentHue, (double)colorSquare1.CurrentSat / 240.0f, 0);
panel1.BackColor = ColorSpaceHelper.HSLtoRGB(MyHSL).ToColor();
}
public void RealizeBrush(XBrush brush, PdfColorMode colorMode)
{
if (brush is XSolidBrush)
{
XColor color = ((XSolidBrush)brush).Color;
color = ColorSpaceHelper.EnsureColorMode(colorMode, color);
if (colorMode != PdfColorMode.Cmyk)
{
if (this.realizedFillColor.Rgb != color.Rgb)
{
this.renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Rgb));
this.renderer.Append(" rg\n");
}
}
else
{
if (!ColorSpaceHelper.IsEqualCmyk(this.realizedFillColor, color))
{
this.renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Cmyk));
this.renderer.Append(" k\n");
}
}
if (this.renderer.Owner.Version >= 14 && this.realizedFillColor.A != color.A)
{
PdfExtGState extGState = this.renderer.Owner.ExtGStateTable.GetExtGStateNonStroke(color.A);
string gs = this.renderer.Resources.AddExtGState(extGState);
this.renderer.AppendFormat("{0} gs\n", gs);
// Must create transparany group
if (this.renderer.page != null && color.A < 1)
{
this.renderer.page.transparencyUsed = true;
}
}
this.realizedFillColor = color;
}
else if (brush is XLinearGradientBrush)
{
XMatrix matrix = this.renderer.defaultViewMatrix;
matrix.Prepend(this.Transform);
PdfShadingPattern pattern = new PdfShadingPattern(this.renderer.Owner);
pattern.SetupFromBrush((XLinearGradientBrush)brush, matrix);
string name = this.renderer.Resources.AddPattern(pattern);
this.renderer.AppendFormat("/Pattern cs\n", name);
this.renderer.AppendFormat("{0} scn\n", name);
// Invalidate fill color
this.realizedFillColor = XColor.Empty;
}
}
private static Color ReadLABColor(EndianBinaryReader reader)
{
ushort x = reader.ReadUInt16();
short y = reader.ReadInt16();
short z = reader.ReadInt16();
ushort w = reader.ReadUInt16();
float La = x / 100.0f;
float Aa = y / 100.0f;
float Bb = z / 100.0f;
return(ColorSpaceHelper.LabtoRGB(La, Aa, Bb).ToColor());
}
private static Color ReadHSBColor(EndianBinaryReader reader)
{
ushort x = reader.ReadUInt16();
ushort y = reader.ReadUInt16();
ushort z = reader.ReadUInt16();
reader.ReadUInt16();
float h = x / 182.04f;
float s = y / 655.35f;
float b = z / 655.35f;
return(ColorSpaceHelper.HSBtoColor(h, s, b));
}
private static Color ReadCMYKColor(EndianBinaryReader reader)
{
ushort x = reader.ReadUInt16();
ushort y = reader.ReadUInt16();
ushort z = reader.ReadUInt16();
ushort w = reader.ReadUInt16();
float c = (100 - (x / 655.35f)) / 100.0f;
float m = (100 - (y / 655.35f)) / 100.0f;
float ye = (100 - (z / 655.35f)) / 100.0f;
float k = (100 - (w / 655.35f)) / 100.0f;
return(ColorSpaceHelper.CMYKtoColor(c, m, ye, k));
}
private void saturationSlider1_LumChanged(object sender, EventArgs e)
{
if (_skipSet)
{
return;
}
_skipSet = true;
numericUpDown3.Value = saturationSlider1.CurrentLum;
panel1.BackColor = ColorSpaceHelper.HSLtoRGB(MyHSL).ToColor();
SetColors();
_skipSet = false;
}
private void RealizeFillColor(XColor color, bool overPrint, PdfColorMode colorMode)
{
color = ColorSpaceHelper.EnsureColorMode(colorMode, color);
switch (color.ColorSpace)
{
case XColorSpace.Rgb:
if (_realizedFillColor.IsEmpty || _realizedFillColor.Rgb != color.Rgb)
{
_renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Rgb));
_renderer.Append(" rg\n");
}
break;
case XColorSpace.Cmyk:
if (_realizedFillColor.IsEmpty || !ColorSpaceHelper.IsEqualCmyk(_realizedFillColor, color))
{
_renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Cmyk));
_renderer.Append(" k\n");
}
break;
case XColorSpace.GrayScale:
if (_realizedFillColor.IsEmpty || _realizedFillColor.GS != color.GS)
{
_renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Undefined));
_renderer.Append(" g\n");
}
break;
default:
break;
}
if (_renderer.Owner.Version >= 14 && color.ColorSpace != XColorSpace.GrayScale && (_realizedFillColor.A != color.A || _realizedNonStrokeOverPrint != overPrint))
{
PdfExtGState extGState = _renderer.Owner.ExtGStateTable.GetExtGStateNonStroke(color.A, overPrint);
string gs = _renderer.Resources.AddExtGState(extGState);
_renderer.AppendFormatString("{0} gs\n", gs);
// Must create transparency group.
if (_renderer._page != null && color.A < 1)
{
_renderer._page.TransparencyUsed = true;
}
}
_realizedFillColor = color;
_realizedNonStrokeOverPrint = overPrint;
}
private void colorSquare1_SatChanged(object sender, EventArgs e)
{
if (_skipSet)
{
return;
}
_skipSet = true;
numericUpDown2.Value = colorSquare1.CurrentSat;
saturationSlider1.Color = new HSL(colorSquare1.CurrentHue, (double)colorSquare1.CurrentSat / 240.0f, 0);
panel1.BackColor = ColorSpaceHelper.HSLtoRGB(MyHSL).ToColor();
SetColors();
_skipSet = false;
}
public static Bitmap GenerateColorSquare(int width, int height)
{
var colorSquare = new Bitmap(width, height);
// START HUE DRAW
Graphics g = Graphics.FromImage(colorSquare);
//Set the hue shades with the correct saturation and luminance
System.Drawing.Color[] theColors =
{
ColorSpaceHelper.HSLtoColor(new HSL(0, 1, 0.5f)),
ColorSpaceHelper.HSLtoColor(new HSL(60, 1, 0.5f)),
ColorSpaceHelper.HSLtoColor(new HSL(120, 1, 0.5f)),
ColorSpaceHelper.HSLtoColor(new HSL(180, 1, 0.5f)),
ColorSpaceHelper.HSLtoColor(new HSL(240, 1, 0.5f)),
ColorSpaceHelper.HSLtoColor(new HSL(300, 1, 0.5f)),
ColorSpaceHelper.HSLtoColor(new HSL(360, 1, 0.5f))
};
//Calculate positions
float percent = 1.0f / 6;
float[] thePositions = { 0.0f, percent, percent * 2, percent * 3, percent * 4, percent * 5, 1.0f };
//Set blend
var theBlend = new ColorBlend();
theBlend.Colors = theColors;
theBlend.Positions = thePositions;
//Get rectangle
var colorRect = new Rectangle(0, 0, width, height);
//Make the linear brush and assign the custom blend to it
var theBrush = new LinearGradientBrush(colorRect,
System.Drawing.Color.Red,
System.Drawing.Color.Red, 0, false);
theBrush.InterpolationColors = theBlend;
//Draw rectangle
g.FillRectangle(theBrush, colorRect);
//END HUE
//START SATURATION
//--- 0% sat 50% lum = 128 r, g and b
System.Drawing.Color halfSatColor = System.Drawing.Color.FromArgb(128, 128, 128);
System.Drawing.Color halfSatColorNoAlpha = System.Drawing.Color.FromArgb(0, 128, 128, 128);
g.FillRectangle(new LinearGradientBrush(colorRect, halfSatColorNoAlpha, halfSatColor, 90, false), colorRect);
//END SATURATION
return(colorSquare);
}
// ******************************************************************
private bool IsFarEnoughFromExistingColor(Color c, double distanceMin)
{
foreach (ColorRatio coloRatio in UsedColors)
{
// double distance = ColorSpaceHelper.GetColorDistance(c, coloRatio.Color);
// This is a lot better differences between color with CIELab calc.
double distance = ColorSpaceHelper.GetColorDistanceCIELab(c, coloRatio.Color) / 100;
if (distance / coloRatio.KeepAwayRatio < distanceMin)
{
return(false); // Too close
}
}
return(true);
}
public override Color BlendColor(Color l, Color r)
{
Color c = r;
HSB hsv = ColorSpaceHelper.RGBtoHSB(c);
hsv.Brightness += (((IsPreview ? _noise : _noise2).NextDouble() - 0.5f) * 2) * GlobalSettings.NoiseSaturation;
if (hsv.Brightness < 0)
{
hsv.Brightness = 0;
}
if (hsv.Brightness > 1)
{
hsv.Brightness = 1;
}
return(Color.FromArgb(r.A, ColorSpaceHelper.HSBtoColor(hsv)));
}
private void RealizeFillColor(XColor color, bool overPrint, PdfColorMode colorMode)
{
color = ColorSpaceHelper.EnsureColorMode(colorMode, color);
if (colorMode != PdfColorMode.Cmyk)
{
if (_realizedFillColor.IsEmpty || _realizedFillColor.Rgb != color.Rgb)
{
_renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Rgb));
_renderer.Append(" rg\n");
}
}
else
{
Debug.Assert(colorMode == PdfColorMode.Cmyk);
if (_realizedFillColor.IsEmpty || !ColorSpaceHelper.IsEqualCmyk(_realizedFillColor, color))
{
_renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Cmyk));
_renderer.Append(" k\n");
}
}
if (_renderer.Owner.Version >= 14 && (_realizedFillColor.A != color.A || _realizedNonStrokeOverPrint != overPrint))
{
PdfExtGState extGState = _renderer.Owner.ExtGStateTable.GetExtGStateNonStroke(color.A, overPrint);
string gs = _renderer.Resources.AddExtGState(extGState);
_renderer.AppendFormatString("{0} gs\n", gs);
// Must create transparency group.
if (_renderer._page != null && color.A < 1)
{
_renderer._page.TransparencyUsed = true;
}
}
_realizedFillColor = color;
_realizedNonStrokeOverPrint = overPrint;
}
public void RealizePen(XPen pen, PdfColorMode colorMode)
{
const string frmt2 = Config.SignificantFigures2;
const string format = Config.SignificantFigures3;
XColor color = pen.Color;
bool overPrint = pen.Overprint;
color = ColorSpaceHelper.EnsureColorMode(colorMode, color);
if (_realizedLineWith != pen._width)
{
_renderer.AppendFormatArgs("{0:" + format + "} w\n", pen._width);
_realizedLineWith = pen._width;
}
if (_realizedLineCap != (int)pen._lineCap)
{
_renderer.AppendFormatArgs("{0} J\n", (int)pen._lineCap);
_realizedLineCap = (int)pen._lineCap;
}
if (_realizedLineJoin != (int)pen._lineJoin)
{
_renderer.AppendFormatArgs("{0} j\n", (int)pen._lineJoin);
_realizedLineJoin = (int)pen._lineJoin;
}
if (_realizedLineCap == (int)XLineJoin.Miter)
{
if (_realizedMiterLimit != (int)pen._miterLimit && (int)pen._miterLimit != 0)
{
_renderer.AppendFormatInt("{0} M\n", (int)pen._miterLimit);
_realizedMiterLimit = (int)pen._miterLimit;
}
}
if (_realizedDashStyle != pen._dashStyle || pen._dashStyle == XDashStyle.Custom)
{
double dot = pen.Width;
double dash = 3 * dot;
// Line width 0 is not recommended but valid.
XDashStyle dashStyle = pen.DashStyle;
if (dot == 0)
{
dashStyle = XDashStyle.Solid;
}
switch (dashStyle)
{
case XDashStyle.Solid:
_renderer.Append("[]0 d\n");
break;
case XDashStyle.Dash:
_renderer.AppendFormatArgs("[{0:" + frmt2 + "} {1:" + frmt2 + "}]0 d\n", dash, dot);
break;
case XDashStyle.Dot:
_renderer.AppendFormatArgs("[{0:" + frmt2 + "}]0 d\n", dot);
break;
case XDashStyle.DashDot:
_renderer.AppendFormatArgs("[{0:" + frmt2 + "} {1:" + frmt2 + "} {1:" + frmt2 + "} {1:" + frmt2 + "}]0 d\n", dash, dot);
break;
case XDashStyle.DashDotDot:
_renderer.AppendFormatArgs("[{0:" + frmt2 + "} {1:" + frmt2 + "} {1:" + frmt2 + "} {1:" + frmt2 + "} {1:" + frmt2 + "} {1:" + frmt2 + "}]0 d\n", dash, dot);
break;
case XDashStyle.Custom:
{
StringBuilder pdf = new StringBuilder("[", 256);
int len = pen._dashPattern == null ? 0 : pen._dashPattern.Length;
for (int idx = 0; idx < len; idx++)
{
if (idx > 0)
{
pdf.Append(' ');
}
pdf.Append(PdfEncoders.ToString(pen._dashPattern[idx] * pen._width));
}
// Make an even number of values look like in GDI+
if (len > 0 && len % 2 == 1)
{
pdf.Append(' ');
pdf.Append(PdfEncoders.ToString(0.2 * pen._width));
}
pdf.AppendFormat(CultureInfo.InvariantCulture, "]{0:" + format + "} d\n", pen._dashOffset * pen._width);
string pattern = pdf.ToString();
// BUG: [email protected] reported a realizing problem
// HACK: I remove the if clause
//if (_realizedDashPattern != pattern)
{
_realizedDashPattern = pattern;
_renderer.Append(pattern);
}
}
break;
}
_realizedDashStyle = dashStyle;
}
if (colorMode != PdfColorMode.Cmyk)
{
if (_realizedStrokeColor.Rgb != color.Rgb)
{
_renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Rgb));
_renderer.Append(" RG\n");
}
}
else
{
if (!ColorSpaceHelper.IsEqualCmyk(_realizedStrokeColor, color))
{
_renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Cmyk));
_renderer.Append(" K\n");
}
}
if (_renderer.Owner.Version >= 14 && (_realizedStrokeColor.A != color.A || _realizedStrokeOverPrint != overPrint))
{
PdfExtGState extGState = _renderer.Owner.ExtGStateTable.GetExtGStateStroke(color.A, overPrint);
string gs = _renderer.Resources.AddExtGState(extGState);
_renderer.AppendFormatString("{0} gs\n", gs);
// Must create transparency group.
if (_renderer._page != null && color.A < 1)
{
_renderer._page.TransparencyUsed = true;
}
}
_realizedStrokeColor = color;
_realizedStrokeOverPrint = overPrint;
}
public void RealizePen(XPen pen, PdfColorMode colorMode)
{
XColor color = pen.Color;
color = ColorSpaceHelper.EnsureColorMode(colorMode, color);
if (realizedLineWith != pen.width)
{
renderer.AppendFormat("{0:0.###} w\n", pen.width);
realizedLineWith = pen.width;
}
if (realizedLineCap != (int)pen.lineCap)
{
renderer.AppendFormat("{0} J\n", (int)pen.lineCap);
realizedLineCap = (int)pen.lineCap;
}
if (realizedLineJoin != (int)pen.lineJoin)
{
renderer.AppendFormat("{0} j\n", (int)pen.lineJoin);
realizedLineJoin = (int)pen.lineJoin;
}
if (realizedLineCap == (int)XLineJoin.Miter)
{
if (realizedMiterLimit != (int)pen.miterLimit && (int)pen.miterLimit != 0)
{
renderer.AppendFormat("{0} M\n", (int)pen.miterLimit);
realizedMiterLimit = (int)pen.miterLimit;
}
}
if (realizedDashStyle != pen.dashStyle || pen.dashStyle == XDashStyle.Custom)
{
double dot = pen.Width;
double dash = 3 * dot;
// Line width 0 is not recommended but valid
XDashStyle dashStyle = pen.DashStyle;
if (dot == 0)
{
dashStyle = XDashStyle.Solid;
}
switch (dashStyle)
{
case XDashStyle.Solid:
renderer.Append("[]0 d\n");
break;
case XDashStyle.Dash:
renderer.AppendFormat("[{0:0.##} {1:0.##}]0 d\n", dash, dot);
break;
case XDashStyle.Dot:
renderer.AppendFormat("[{0:0.##}]0 d\n", dot);
break;
case XDashStyle.DashDot:
renderer.AppendFormat("[{0:0.##} {1:0.##} {1:0.##} {1:0.##}]0 d\n", dash, dot);
break;
case XDashStyle.DashDotDot:
renderer.AppendFormat("[{0:0.##} {1:0.##} {1:0.##} {1:0.##} {1:0.##} {1:0.##}]0 d\n", dash, dot);
break;
case XDashStyle.Custom:
{
StringBuilder pdf = new StringBuilder("[", 256);
int len = pen.dashPattern == null ? 0 : pen.dashPattern.Length;
for (int idx = 0; idx < len; idx++)
{
if (idx > 0)
{
pdf.Append(' ');
}
pdf.Append(PdfEncoders.ToString(pen.dashPattern[idx] * pen.width));
}
// Make an even number of values look like in GDI+
if (len > 0 && len % 2 == 1)
{
pdf.Append(' ');
pdf.Append(PdfEncoders.ToString(0.2 * pen.width));
}
pdf.AppendFormat(CultureInfo.InvariantCulture, "]{0:0.###} d\n", pen.dashOffset * pen.width);
string pattern = pdf.ToString();
// BUG: [email protected] reported a realizing problem
// HACK: I romove the if clause
//if (this.realizedDashPattern != pattern)
{
realizedDashPattern = pattern;
renderer.Append(pattern);
}
}
break;
}
realizedDashStyle = dashStyle;
}
if (colorMode != PdfColorMode.Cmyk)
{
if (realizedStrokeColor.Rgb != color.Rgb)
{
renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Rgb));
renderer.Append(" RG\n");
}
}
else
{
if (!ColorSpaceHelper.IsEqualCmyk(realizedStrokeColor, color))
{
renderer.Append(PdfEncoders.ToString(color, PdfColorMode.Cmyk));
renderer.Append(" K\n");
}
}
if (renderer.Owner.Version >= 14 && realizedStrokeColor.A != color.A)
{
PdfExtGState extGState = renderer.Owner.ExtGStateTable.GetExtGStateStroke(color.A);
string gs = renderer.Resources.AddExtGState(extGState);
renderer.AppendFormat("{0} gs\n", gs);
// Must create transparany group
if (renderer.page != null && color.A < 1)
{
renderer.page.transparencyUsed = true;
}
}
realizedStrokeColor = color;
}
private void ColorPicker_Load(object sender, EventArgs e)
{
panel1.BackColor = ColorSpaceHelper.HSLtoRGB(MyHSL).ToColor();
saturationSlider1.Color = new HSL(colorSquare1.CurrentHue, (double)colorSquare1.CurrentSat / 240.0f, 0);
SetColors();
}
/// <summary>
/// Setups the shading from the specified brush.
/// </summary>
public void SetupFromBrush(XLinearGradientBrush brush)
{
if (brush == null)
{
throw new ArgumentNullException("brush");
}
PdfColorMode colorMode = this.document.Options.ColorMode;
XColor color1 = ColorSpaceHelper.EnsureColorMode(colorMode, brush.color1);
XColor color2 = ColorSpaceHelper.EnsureColorMode(colorMode, brush.color2);
PdfDictionary function = new PdfDictionary();
Elements[Keys.ShadingType] = new PdfInteger(2);
if (colorMode != PdfColorMode.Cmyk)
{
Elements[Keys.ColorSpace] = new PdfName("/DeviceRGB");
}
else
{
Elements[Keys.ColorSpace] = new PdfName("/DeviceCMYK");
}
double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
if (brush.useRect)
{
switch (brush.linearGradientMode)
{
case XLinearGradientMode.Horizontal:
x1 = brush.rect.x;
y1 = brush.rect.y;
x2 = brush.rect.x + brush.rect.width;
y2 = brush.rect.y;
break;
case XLinearGradientMode.Vertical:
x1 = brush.rect.x;
y1 = brush.rect.y;
x2 = brush.rect.x;
y2 = brush.rect.y + brush.rect.height;
break;
case XLinearGradientMode.ForwardDiagonal:
x1 = brush.rect.x;
y1 = brush.rect.y;
x2 = brush.rect.x + brush.rect.width;
y2 = brush.rect.y + brush.rect.height;
break;
case XLinearGradientMode.BackwardDiagonal:
x1 = brush.rect.x + brush.rect.width;
y1 = brush.rect.y;
x2 = brush.rect.x;
y2 = brush.rect.y + brush.rect.height;
break;
}
}
else
{
x1 = brush.point1.x;
y1 = brush.point1.y;
x2 = brush.point2.x;
y2 = brush.point2.y;
}
Elements[Keys.Coords] = new PdfLiteral("[{0:0.###} {1:0.###} {2:0.###} {3:0.###}]", x1, y1, x2, y2);
//Elements[Keys.Background] = new PdfRawItem("[0 1 1]");
//Elements[Keys.Domain] =
Elements[Keys.Function] = function;
//Elements[Keys.Extend] = new PdfRawItem("[true true]");
string clr1 = "[" + PdfEncoders.ToString(color1, colorMode) + "]";
string clr2 = "[" + PdfEncoders.ToString(color2, colorMode) + "]";
function.Elements["/FunctionType"] = new PdfInteger(2);
function.Elements["/C0"] = new PdfLiteral(clr1);
function.Elements["/C1"] = new PdfLiteral(clr2);
function.Elements["/Domain"] = new PdfLiteral("[0 1]");
function.Elements["/N"] = new PdfInteger(1);
}
/// <summary>
/// Setups the shading from the specified brush.
/// </summary>
internal void SetupFromBrush(XLinearGradientBrush brush, XGraphicsPdfRenderer renderer)
{
if (brush == null)
{
throw new ArgumentNullException("brush");
}
PdfColorMode colorMode = _document.Options.ColorMode;
XColor color1 = ColorSpaceHelper.EnsureColorMode(colorMode, brush._color1);
XColor color2 = ColorSpaceHelper.EnsureColorMode(colorMode, brush._color2);
PdfDictionary function = new PdfDictionary();
Elements[Keys.ShadingType] = new PdfInteger(2);
if (colorMode != PdfColorMode.Cmyk)
{
Elements[Keys.ColorSpace] = new PdfName("/DeviceRGB");
}
else
{
Elements[Keys.ColorSpace] = new PdfName("/DeviceCMYK");
}
double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
if (brush._useRect)
{
XPoint pt1 = renderer.WorldToView(brush._rect.TopLeft);
XPoint pt2 = renderer.WorldToView(brush._rect.BottomRight);
switch (brush._linearGradientMode)
{
case XLinearGradientMode.Horizontal:
x1 = pt1.X;
y1 = pt1.Y;
x2 = pt2.X;
y2 = pt1.Y;
break;
case XLinearGradientMode.Vertical:
x1 = pt1.X;
y1 = pt1.Y;
x2 = pt1.X;
y2 = pt2.Y;
break;
case XLinearGradientMode.ForwardDiagonal:
x1 = pt1.X;
y1 = pt1.Y;
x2 = pt2.X;
y2 = pt2.Y;
break;
case XLinearGradientMode.BackwardDiagonal:
x1 = pt2.X;
y1 = pt1.Y;
x2 = pt1.X;
y2 = pt2.Y;
break;
}
}
else
{
XPoint pt1 = renderer.WorldToView(brush._point1);
XPoint pt2 = renderer.WorldToView(brush._point2);
x1 = pt1.X;
y1 = pt1.Y;
x2 = pt2.X;
y2 = pt2.Y;
}
const string format = Config.SignificantFigures3;
Elements[Keys.Coords] = new PdfLiteral("[{0:" + format + "} {1:" + format + "} {2:" + format + "} {3:" + format + "}]", x1, y1, x2, y2);
//Elements[Keys.Background] = new PdfRawItem("[0 1 1]");
//Elements[Keys.Domain] =
Elements[Keys.Function] = function;
//Elements[Keys.Extend] = new PdfRawItem("[true true]");
string clr1 = "[" + PdfEncoders.ToString(color1, colorMode) + "]";
string clr2 = "[" + PdfEncoders.ToString(color2, colorMode) + "]";
function.Elements["/FunctionType"] = new PdfInteger(2);
function.Elements["/C0"] = new PdfLiteral(clr1);
function.Elements["/C1"] = new PdfLiteral(clr2);
function.Elements["/Domain"] = new PdfLiteral("[0 1]");
function.Elements["/N"] = new PdfInteger(1);
}
public void TryParse()
{
Assert.True(ColorSpaceHelper.TryParse("RGB", out _));
Assert.False(ColorSpaceHelper.TryParse("RGBq", out _));
}
