void DrawBrushPath(Graphics g)
{
if (_latestBrushPathCache != null)
{
PixelFarm.Drawing.Color brushColor = _myBrushPath.FillColor;
using (var br = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(brushColor.alpha, brushColor.red, brushColor.green, brushColor.blue)))
{
g.FillPath(br, _latestBrushPathCache);
}
return;
}
if (_myBrushPath.Vxs != null)
{
//create new path
_latestBrushPathCache = PixelFarm.Drawing.WinGdi.VxsHelper.CreateGraphicsPath(_myBrushPath.Vxs);
PixelFarm.Drawing.Color brushColor = _myBrushPath.FillColor;
using (var br = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(brushColor.alpha, brushColor.red, brushColor.green, brushColor.blue)))
{
g.FillPath(br, _latestBrushPathCache);
}
}
else
{
var contPoints = _myBrushPath.contPoints;
int pcount = contPoints.Count;
for (int i = 1; i < pcount; ++i)
{
var p0 = contPoints[i - 1];
var p1 = contPoints[i];
g.DrawLine(Pens.Red, (float)p0.x, (float)p0.y, (float)p1.x, (float)p1.y);
}
}
}
public void ChangeFontColor(Color newcolor)
{
//change prop
//then need to evaluate
if (elem == null)
{
return;
}
BoxSpec boxSpec = elem.Spec;
if (boxSpec.ActualColor == newcolor)
{
return;
}
HtmlElement.InvokeNotifyChangeOnIdleState(
elem,
ElementChangeKind.Spec);
//-------------------------------------
var existingRuleSet = elem.ElementRuleSet;
if (existingRuleSet == null)
{
//create new one
elem.ElementRuleSet = existingRuleSet = new CssRuleSet();
elem.IsStyleEvaluated = true;
}
existingRuleSet.AddCssCodeProperty(
new CssPropertyDeclaration(
WellknownCssPropertyName.Color,
new CssCodeColor(
CssColorConv.ConvertToCssColor(newcolor))));
HtmlElement.InvokeNotifyChangeOnIdleState(elem, ElementChangeKind.Spec);
}
public void FillRoundRect(PixelFarm.Drawing.Color color, float x, float y, float w, float h, float rx, float ry)
{
roundRect.SetRect(x, y, x + w, y + h);
roundRect.SetRadius(rx, ry);
//create round rect vxs
var vxs = roundRect.MakeVxs();
switch (this.SmoothMode)
{
case CanvasSmoothMode.AggSmooth:
{
sclineRas.Reset();
sclineRas.AddPath(vxs);
sclineRasToGL.FillWithColor(sclineRas, sclinePack8, color);
}
break;
default:
{
sclineRas.Reset();
sclineRas.AddPath(vxs);
sclineRasToGL.DrawWithColor(sclineRas, sclinePack8, color);
}
break;
}
}
EaseBox CreateGripper(PixelFarm.Drawing.Color bgcolor, bool isVertical)
{
int controllerBoxWH = 10;
var gripperBox = new SimpleBox(controllerBoxWH, controllerBoxWH);
gripperBox.BackColor = bgcolor;
//---------------------------------------------------------------------
gripperBox.MouseDrag += (s, e) =>
{
Point pos = gripperBox.Position;
if (isVertical)
{
gripperBox.SetLocation(pos.X, pos.Y + e.YDiff);
}
else
{
gripperBox.SetLocation(pos.X + e.XDiff, pos.Y);
}
this.ninespaceGrippers.UpdateNinespaces();
e.MouseCursorStyle = MouseCursorStyle.Pointer;
e.CancelBubbling = true;
};
gripperBox.MouseUp += (s, e) =>
{
e.MouseCursorStyle = MouseCursorStyle.Default;
e.CancelBubbling = true;
};
return(gripperBox);
}
static SimpleBox CreateSpaceBox(SpaceName name, Color bgcolor)
{
int controllerBoxWH = 10;
SimpleBox spaceBox = new SimpleBox(controllerBoxWH, controllerBoxWH);
spaceBox.BackColor = bgcolor;
spaceBox.Tag = name;
return spaceBox;
}
public void FillPolygon(PixelFarm.Drawing.Color color, float[] vertex2dCoords, int npoints)
{
//-------------
//Tesselate
//2d coods lis
//n point
switch (this.SmoothMode)
{
case CanvasSmoothMode.AggSmooth:
{
//closed polygon
//closed polygon
int j = npoints / 2;
//first point
if (j < 2)
{
return;
}
ps.MoveTo(vertex2dCoords[0], vertex2dCoords[1]);
int nn = 2;
for (int i = 1; i < j; ++i)
{
ps.LineTo(vertex2dCoords[nn++],
vertex2dCoords[nn++]);
}
//close
ps.CloseFigure();
VertexStore vxs = ps.Vxs;
sclineRas.Reset();
sclineRas.AddPath(vxs);
sclineRasToGL.FillWithColor(sclineRas, sclinePack8, color);
}
break;
default:
{
List <Vertex> vertextList = TessPolygon(vertex2dCoords);
int j = vertextList.Count;
//-----------------------------
//fill polygon with solid color
unsafe
{
float *vtx = stackalloc float[j * 2];
int n = 0;
for (int i = 0; i < j; ++i)
{
var v = vertextList[i];
vtx[n] = (float)v.m_X;
vtx[n + 1] = (float)v.m_Y;
n += 2;
}
UnsafeDrawV2fList(DrawMode.Triangles, vtx, j, color);
}
}
break;
}
}
static CustomWidgets.EaseBox CreateSpaceBox(SpaceName name, PixelFarm.Drawing.Color bgcolor)
{
int controllerBoxWH = 10;
var tinyBox = new CustomWidgets.SimpleBox(controllerBoxWH, controllerBoxWH);
tinyBox.BackColor = bgcolor;
tinyBox.Tag = name;
return(tinyBox);
}
void Blend(ActualImage destImg, byte[] greyBuff, int greyBufferWidth, int greyBufferHeight)
{
PixelFarm.Drawing.Color color = PixelFarm.Drawing.Color.Black;
for (int y = 0; y < greyBufferHeight; ++y)
{
BlendScanline(destImg, greyBuff, color, 0, y, greyBufferWidth);
}
//SwapRB(destImg);
}
public void FillRect(PixelFarm.Drawing.Color color, float x, float y, float w, float h)
{
//fill with solid color
unsafe
{
//set color
float *rectCoords = stackalloc float[12];
CreateRectCoords(rectCoords, x, y, w, h);
UnsafeDrawV2fList(DrawMode.Triangles, rectCoords, 6, color);
}
}
public static void UnsafeDirectSetData(SpriteShape lion,
int numPaths,
PathWriter pathStore,
Color[] colors,
int[] pathIndice)
{
lion.path = pathStore;
lion.colors = colors;
lion.pathIndexList = pathIndice;
lion.numPaths = numPaths;
lion.UpdateBoundingRect();
}
void BlendScanline(ActualImage destImg, byte[] expandGreyBuffer,
PixelFarm.Drawing.Color color, int x, int y, int width)
{
byte[] rgb = new byte[3] {
color.R,
color.G,
color.B
};
//-------------------------
//destination
TempMemPtr memPtr = ActualImage.GetBufferPtr(destImg);
//start pixel
int destImgIndex = (x * 4) + (destImg.Stride * y);
//start img src
int srcImgIndex = x + (width * y);
int colorIndex = 0;
int round = 0;
byte color_a = color.alpha;
unsafe
{
byte *destImgBuffer = (byte *)memPtr.Ptr;
while (width > 3)
{
int a0 = expandGreyBuffer[srcImgIndex] * color_a;
int a1 = expandGreyBuffer[srcImgIndex + 1] * color_a;
int a2 = expandGreyBuffer[srcImgIndex + 2] * color_a;
byte ec0 = destImgBuffer[destImgIndex]; //existing color
byte ec1 = destImgBuffer[destImgIndex + 1]; //existing color
byte ec2 = destImgBuffer[destImgIndex + 2]; //existing color
//------------------------------------------------------
//please note that we swap a2 and a0 on the fly****
//------------------------------------------------------
byte n0 = (byte)((((rgb[colorIndex] - ec0) * a2) + (ec0 << 16)) >> 16);
byte n1 = (byte)((((rgb[colorIndex + 1] - ec1) * a1) + (ec1 << 16)) >> 16);
byte n2 = (byte)((((rgb[colorIndex + 2] - ec2) * a0) + (ec2 << 16)) >> 16);
destImgBuffer[destImgIndex] = n0;
destImgBuffer[destImgIndex + 1] = n1;
destImgBuffer[destImgIndex + 2] = n2;
destImgIndex += 4;
round = 0;
colorIndex = 0;
srcImgIndex += 3;
width -= 3;
}
memPtr.Release();
}
}
public void Clear(PixelFarm.Drawing.Color c)
{
//set value for clear color buffer
GL.ClearColor(
(float)c.R / 255f,
(float)c.G / 255f,
(float)c.B / 255f,
(float)c.A / 255f);
GL.ClearStencil(0);
//actual clear here
GL.Clear(ClearBufferMask.ColorBufferBit |
ClearBufferMask.DepthBufferBit |
ClearBufferMask.StencilBufferBit);
}
public static TextSpanStyle CreateNewStyle(Color color)
{
if (color != Color.Empty)
{
TextSpanStyle simpleBeh = new TextSpanStyle();
// simpleBeh.SharedBgColorBrush = new ArtSolidBrush(color);
return simpleBeh;
}
else
{
TextSpanStyle simpleBeh = new TextSpanStyle();
//simpleBeh.SharedBgColorBrush = new ArtSolidBrush(color);
return simpleBeh;
}
}
public static void WriteColorsToStream(BinaryWriter writer, Color[] colors)
{
int len = colors.Length;
//1.
writer.Write(len);
for (int i = 0; i < len; ++i)
{
Color color = colors[i];
writer.Write(color.red);
writer.Write(color.green);
writer.Write(color.blue);
writer.Write(color.alpha);
}
writer.Write((int)0);
writer.Flush();
}
public void SetPixelHighRes(ImageReaderWriterBase sourceImage,
Color[] destBuffer,
int destBufferOffset,
int x,
int y)
{
int r, g, b, a;
r = g = b = a = LineAA.SUBPIXEL_SCALE * LineAA.SUBPIXEL_SCALE / 2;
int weight;
int x_lr = x >> LineAA.SUBPIXEL_SHIFT;
int y_lr = y >> LineAA.SUBPIXEL_SHIFT;
x &= LineAA.SUBPIXEL_MARK;
y &= LineAA.SUBPIXEL_MARK;
int sourceOffset;
byte[] ptr = sourceImage.GetBuffer();
sourceOffset = sourceImage.GetBufferOffsetXY(x_lr, y_lr);
weight = (LineAA.SUBPIXEL_SCALE - x) *
(LineAA.SUBPIXEL_SCALE - y);
r += weight * ptr[sourceOffset + CO.R];
g += weight * ptr[sourceOffset + CO.G];
b += weight * ptr[sourceOffset + CO.B];
a += weight * ptr[sourceOffset + CO.A];
sourceOffset += sourceImage.BytesBetweenPixelsInclusive;
weight = x * (LineAA.SUBPIXEL_SCALE - y);
r += weight * ptr[sourceOffset + CO.R];
g += weight * ptr[sourceOffset + CO.G];
b += weight * ptr[sourceOffset + CO.B];
a += weight * ptr[sourceOffset + CO.A];
sourceOffset = sourceImage.GetBufferOffsetXY(x_lr, y_lr + 1);
weight = (LineAA.SUBPIXEL_SCALE - x) * y;
r += weight * ptr[sourceOffset + CO.R];
g += weight * ptr[sourceOffset + CO.G];
b += weight * ptr[sourceOffset + CO.B];
a += weight * ptr[sourceOffset + CO.A];
sourceOffset += sourceImage.BytesBetweenPixelsInclusive;
weight = x * y;
r += weight * ptr[sourceOffset + CO.R];
g += weight * ptr[sourceOffset + CO.G];
b += weight * ptr[sourceOffset + CO.B];
a += weight * ptr[sourceOffset + CO.A];
destBuffer[destBufferOffset].red = (byte)(r >> LineAA.SUBPIXEL_SHIFT * 2);
destBuffer[destBufferOffset].green = (byte)(g >> LineAA.SUBPIXEL_SHIFT * 2);
destBuffer[destBufferOffset].blue = (byte)(b >> LineAA.SUBPIXEL_SHIFT * 2);
destBuffer[destBufferOffset].alpha = (byte)(a >> LineAA.SUBPIXEL_SHIFT * 2);
}
public void ChangeBackgroundColor(Color backgroundColor)
{
if (elem == null)
{
return;
}
BoxSpec boxSpec = elem.Spec;
if (boxSpec.BackgroundColor == backgroundColor)
{
return;
}
var existingRuleSet = elem.ElementRuleSet;
if (existingRuleSet == null)
{
//create new one
elem.ElementRuleSet = existingRuleSet = new CssRuleSet();
elem.IsStyleEvaluated = false;
}
//-------------------------------------
existingRuleSet.RemoveCssProperty(WellknownCssPropertyName.BackgroundColor);
existingRuleSet.AddCssCodeProperty(
new CssPropertyDeclaration(
WellknownCssPropertyName.BackgroundColor,
new CssCodeColor(CssColorConv.ConvertToCssColor(backgroundColor))));
elem.SkipPrincipalBoxEvalulation = false;
CssBox cssbox = HtmlElement.InternalGetPrincipalBox(elem);
if (cssbox != null)
{
#if DEBUG
cssbox.dbugMark1++;
#endif
CssBox.InvalidateComputeValue(cssbox);
}
HtmlElement.InvokeNotifyChangeOnIdleState(
elem,
ElementChangeKind.Spec);
InvalidateCssBox(cssbox);
}
public void FillVxsSnap(PixelFarm.Drawing.Color color, VertexStoreSnap snap)
{
switch (this.SmoothMode)
{
case CanvasSmoothMode.AggSmooth:
{
sclineRas.Reset();
sclineRas.AddPath(snap);
sclineRasToGL.DrawWithColor(sclineRas, sclinePack8, color);
} break;
default:
{
sclineRas.Reset();
sclineRas.AddPath(snap);
sclineRasToGL.DrawWithColor(sclineRas, sclinePack8, color);
} break;
}
}
//--------------------------------------------------------------------
public void GenerateColors(Color[] outputColors, int startIndex, int x, int y, int len)
{
m_interpolator.Begin(x + 0.5, y + 0.5, len);
do
{
m_interpolator.GetCoord(out x, out y);
float d = m_grValueCalculator.Calculate(x >> DOWN_SCALE_SHIFT,
y >> DOWN_SCALE_SHIFT,
m_d2);
d = ((d - m_d1) * stepRatio);
if (d < 0) d = 0;
if (d >= m_colorsProvider.GradientSteps)
{
d = m_colorsProvider.GradientSteps - 1;
}
outputColors[startIndex++] = m_colorsProvider.GetColor((int)d);
m_interpolator.Next();
}
while (--len != 0);
}
public override void ReEvaluateComputeValue(ref ReEvaluateArgs args)
{
var myspec = this.imageSpec;
this.fillColor = myspec.ActualColor;
this.strokeColor = myspec.StrokeColor;
this.ActualX = ConvertToPx(myspec.X, ref args);
this.ActualY = ConvertToPx(myspec.Y, ref args);
this.ActualWidth = ConvertToPx(myspec.Width, ref args);
this.ActualHeight = ConvertToPx(myspec.Height, ref args);
this.ActualStrokeWidth = ConvertToPx(myspec.StrokeWidth, ref args);
this._path = CreateRectGraphicPath(
this.ActualX,
this.ActualY,
this.ActualWidth,
this.ActualHeight);
if (this._imgRun.ImageBinder == null)
{
this._imgRun.ImageBinder = new SvgImageBinder(myspec.ImageSrc);
}
ValidatePath();
}
//-------------------------------------------------------------------------------
public void FillVxs(PixelFarm.Drawing.Color color, VertexStore vxs)
{
//solid brush
switch (this.SmoothMode)
{
case CanvasSmoothMode.AggSmooth:
{
sclineRas.Reset();
sclineRas.AddPath(vxs);
sclineRasToGL.DrawWithColor(sclineRas, sclinePack8, color);
} break;
default:
{
//tess the vxs first
sclineRas.Reset();
sclineRas.AddPath(vxs);
sclineRasToGL.DrawWithColor(sclineRas, sclinePack8, color);
//throw new NotSupportedException();
} break;
}
}
protected virtual void CustomRenderSingleScanLine(
IImageReaderWriter dest,
Scanline scline,
Color color)
{
//implement
}
public void FillPolygon(PixelFarm.Drawing.Color color, float[] vertex2dCoords)
{
FillPolygon(color, vertex2dCoords, vertex2dCoords.Length);
}
public void FillEllipse(PixelFarm.Drawing.Color color, float x, float y, float rx, float ry)
{
ellipse.Reset(x, y, rx, ry);
var vxs = ellipse.MakeVxs();
switch (this.SmoothMode)
{
case CanvasSmoothMode.AggSmooth:
{
sclineRas.Reset();
sclineRas.AddPath(vxs);
sclineRasToGL.DrawWithColor(sclineRas, sclinePack8, color);
} break;
default:
{ //other mode
int n = vxs.Count;
//make triangular fan***
unsafe
{
float *coords = stackalloc float[(n * 2) + 4];
int i = 0;
int nn = 0;
int npoints = 0;
double vx, vy;
//center
coords[nn++] = (float)x;
coords[nn++] = (float)y;
npoints++;
var cmd = vxs.GetVertex(i, out vx, out vy);
while (i < n)
{
switch (cmd)
{
case VertexCmd.MoveTo:
{
coords[nn++] = (float)vx;
coords[nn++] = (float)vy;
npoints++;
} break;
case VertexCmd.LineTo:
{
coords[nn++] = (float)vx;
coords[nn++] = (float)vy;
npoints++;
} break;
case VertexCmd.Stop:
{
} break;
default:
{
} break;
}
i++;
cmd = vxs.GetVertex(i, out vx, out vy);
}
//close circle
coords[nn++] = coords[2];
coords[nn++] = coords[3];
npoints++;
UnsafeDrawV2fList(DrawMode.TriangleFan, coords, npoints, color);
}
} break;
}
}
public override void BlendSolidVSpan(int x, int y, int len, Color c, byte[] covers, int coversIndex)
{
linkedImage.BlendSolidHSpan(y, x, len, c, covers, coversIndex);
}
public override void BlendColorVSpan(int x, int y, int len, Color[] colors, int colorsIndex, byte[] covers, int coversIndex, bool firstCoverForAll)
{
linkedImage.BlendColorHSpan(y, x, len, colors, colorsIndex, covers, coversIndex, firstCoverForAll);
}
public abstract void Line(double x1, double y1, double x2, double y2, Color color);
public override void BlendHL(int x1, int y, int x2, Color c, byte cover)
{
linkedImage.BlendVL(y, x1, x2, c, cover);
}
public LinearGradientColorsProvider(Color c1, Color c2)
: this(c1, c2, 256)
{
}
public LinearGradientColorsProvider(Color c1, Color c2, int gradientSteps)
{
m_c1 = c1;
m_c2 = c2;
this.gradientSteps = gradientSteps;
}
public void DrawGlyphImages3(PixelFarm.Drawing.Color color,
GLBitmap bmp, PixelFarm.Drawing.RectangleF[] destAndSrcPairs)
{
//GL.Disable(EnableCap.Blend);
//GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
////GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.Zero);
unsafe
{
var prevColor = this.strokeColor;
this.StrokeColor = PixelFarm.Drawing.Color.White;
GL.Enable(EnableCap.Texture2D);
{
GL.BindTexture(TextureTarget.Texture2D, GetTextureId(bmp));
// GL.TexEnv(TextureEnvTarget.TextureEnv, TextureEnvParameter.TextureEnvMode, (int)TextureEnvMode.Combine);
GL.EnableClientState(ArrayCap.TextureCoordArray); //***
//texture source coord 1= 100% of original width
float *arr = stackalloc float[8];
float fullsrcW = bmp.Width;
float fullsrcH = bmp.Height;
int len = destAndSrcPairs.Length;
if (len > 1)
{
if ((len % 2 != 0))
{
len -= 1;
}
if (this.canvasOrientation == Drawing.CanvasOrientation.LeftTop)
{
for (int i = 0; i < len;)
{
//each
var destRect = destAndSrcPairs[i];
var srcRect = destAndSrcPairs[i + 1];
i += 2;
if (!bmp.IsInvert)
{
////arr[0] = 0; arr[1] = 0;
arr[0] = srcRect.Left / fullsrcW; arr[1] = (srcRect.Top + srcRect.Height) / fullsrcH;
//arr[2] = 1; arr[3] = 0;
arr[2] = srcRect.Right / fullsrcW; arr[3] = (srcRect.Top + srcRect.Height) / fullsrcH;
//arr[4] = 1; arr[5] = 1;
arr[4] = srcRect.Right / fullsrcW; arr[5] = srcRect.Top / fullsrcH;
//arr[6] = 0; arr[7] = 1;
arr[6] = srcRect.Left / fullsrcW; arr[7] = srcRect.Top / fullsrcH;
}
else
{
arr[0] = srcRect.Left / fullsrcW; arr[1] = srcRect.Top / fullsrcH;
//arr[2] = 1; arr[3] = 1;
arr[2] = srcRect.Right / fullsrcW; arr[3] = srcRect.Top / fullsrcH;
//arr[4] = 1; arr[5] = 0;
arr[4] = srcRect.Right / fullsrcW; arr[5] = srcRect.Bottom / fullsrcH;
//arr[6] = 0; arr[7] = 0;
arr[6] = srcRect.Left / fullsrcW; arr[7] = srcRect.Bottom / fullsrcH;
}
GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, (IntPtr)arr);
//------------------------------------------
//fill rect with texture
FillRectWithTexture(destRect.X, destRect.Y, destRect.Width, destRect.Height);
}
}
else
{
for (int i = 0; i < len;)
{
//each
var destRect = destAndSrcPairs[i];
var srcRect = destAndSrcPairs[i + 1];
i += 2;
if (bmp.IsInvert)
{
////arr[0] = 0; arr[1] = 0;
arr[0] = srcRect.Left / fullsrcW; arr[1] = (srcRect.Top + srcRect.Height) / fullsrcH;
//arr[2] = 1; arr[3] = 0;
arr[2] = srcRect.Right / fullsrcW; arr[3] = (srcRect.Top + srcRect.Height) / fullsrcH;
//arr[4] = 1; arr[5] = 1;
arr[4] = srcRect.Right / fullsrcW; arr[5] = srcRect.Top / fullsrcH;
//arr[6] = 0; arr[7] = 1;
arr[6] = srcRect.Left / fullsrcW; arr[7] = srcRect.Top / fullsrcH;
}
else
{
arr[0] = srcRect.Left / fullsrcW; arr[1] = srcRect.Top / fullsrcH;
//arr[2] = 1; arr[3] = 1;
arr[2] = srcRect.Right / fullsrcW; arr[3] = srcRect.Top / fullsrcH;
//arr[4] = 1; arr[5] = 0;
arr[4] = srcRect.Right / fullsrcW; arr[5] = srcRect.Bottom / fullsrcH;
//arr[6] = 0; arr[7] = 0;
arr[6] = srcRect.Left / fullsrcW; arr[7] = srcRect.Bottom / fullsrcH;
}
GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, (IntPtr)arr);
//------------------------------------------
//fill rect with texture
FillRectWithTexture(destRect.X, destRect.Y, destRect.Width, destRect.Height);
}
}
}
GL.DisableClientState(ArrayCap.TextureCoordArray);
}
GL.Disable(EnableCap.Texture2D);
this.StrokeColor = prevColor;
}
////enable color again
//////at this point alpha component is fill in to destination
//////-------------------------------------------------------------------------------------
//////2. then fill again!,
//////we use alpha information from dest,
//////so we set blend func to ... GL.BlendFunc(BlendingFactorSrc.DstAlpha, BlendingFactorDest.OneMinusDstAlpha)
//GL.ColorMask(true, true, true, true);
//GL.BlendFunc(BlendingFactorSrc.DstAlpha, BlendingFactorDest.OneMinusDstAlpha);
//{
// int len = destAndSrcPairs.Length;
// if (len > 1)
// {
// for (int i = 0; i < len; )
// {
// //each
// var destRect = destAndSrcPairs[i];
// var srcRect = destAndSrcPairs[i + 1];
// i += 2;
// FillRect(color, destRect.X, destRect.Y, destRect.Width, destRect.Height);
// }
// }
//}
////3.
////set blend mode back
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
////fill with color
}
public void DrawGlyphImages(PixelFarm.Drawing.Color color,
GLBitmap bmp, PixelFarm.Drawing.RectangleF[] destAndSrcPairs)
{
//TODO: white opaque bg should render in single pass
//----------------------------
//in this version: this technique *** use gray scale gradient , not subpixel rendering
//TODO: add subpixel rendering support**
//see also: FillPolygon ***
//double pass technique:
//--------
GL.ColorMask(false, false, false, true);
//use alpha channel from source***
GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.Zero);
unsafe
{
var prevColor = this.strokeColor;
this.StrokeColor = PixelFarm.Drawing.Color.White;
GL.Enable(EnableCap.Texture2D);
{
GL.BindTexture(TextureTarget.Texture2D, GetTextureId(bmp));
GL.EnableClientState(ArrayCap.TextureCoordArray); //***
//texture source coord 1= 100% of original width
float *arr = stackalloc float[8];
float fullsrcW = bmp.Width;
float fullsrcH = bmp.Height;
int len = destAndSrcPairs.Length;
if (len > 1)
{
if ((len % 2 != 0))
{
len -= 1;
}
if (this.canvasOrientation == Drawing.CanvasOrientation.LeftTop)
{
for (int i = 0; i < len;)
{
//each
var destRect = destAndSrcPairs[i];
var srcRect = destAndSrcPairs[i + 1];
i += 2;
if (!bmp.IsInvert)
{
////arr[0] = 0; arr[1] = 0;
arr[0] = srcRect.Left / fullsrcW; arr[1] = (srcRect.Top + srcRect.Height) / fullsrcH;
//arr[2] = 1; arr[3] = 0;
arr[2] = srcRect.Right / fullsrcW; arr[3] = (srcRect.Top + srcRect.Height) / fullsrcH;
//arr[4] = 1; arr[5] = 1;
arr[4] = srcRect.Right / fullsrcW; arr[5] = srcRect.Top / fullsrcH;
//arr[6] = 0; arr[7] = 1;
arr[6] = srcRect.Left / fullsrcW; arr[7] = srcRect.Top / fullsrcH;
}
else
{
arr[0] = srcRect.Left / fullsrcW; arr[1] = srcRect.Top / fullsrcH;
//arr[2] = 1; arr[3] = 1;
arr[2] = srcRect.Right / fullsrcW; arr[3] = srcRect.Top / fullsrcH;
//arr[4] = 1; arr[5] = 0;
arr[4] = srcRect.Right / fullsrcW; arr[5] = srcRect.Bottom / fullsrcH;
//arr[6] = 0; arr[7] = 0;
arr[6] = srcRect.Left / fullsrcW; arr[7] = srcRect.Bottom / fullsrcH;
}
GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, (IntPtr)arr);
//------------------------------------------
//fill rect with texture
FillRectWithTexture(destRect.X, destRect.Y, destRect.Width, destRect.Height);
}
}
else
{
for (int i = 0; i < len;)
{
//each
var destRect = destAndSrcPairs[i];
var srcRect = destAndSrcPairs[i + 1];
i += 2;
if (bmp.IsInvert)
{
////arr[0] = 0; arr[1] = 0;
arr[0] = srcRect.Left / fullsrcW; arr[1] = (srcRect.Top + srcRect.Height) / fullsrcH;
//arr[2] = 1; arr[3] = 0;
arr[2] = srcRect.Right / fullsrcW; arr[3] = (srcRect.Top + srcRect.Height) / fullsrcH;
//arr[4] = 1; arr[5] = 1;
arr[4] = srcRect.Right / fullsrcW; arr[5] = srcRect.Top / fullsrcH;
//arr[6] = 0; arr[7] = 1;
arr[6] = srcRect.Left / fullsrcW; arr[7] = srcRect.Top / fullsrcH;
}
else
{
arr[0] = srcRect.Left / fullsrcW; arr[1] = srcRect.Top / fullsrcH;
//arr[2] = 1; arr[3] = 1;
arr[2] = srcRect.Right / fullsrcW; arr[3] = srcRect.Top / fullsrcH;
//arr[4] = 1; arr[5] = 0;
arr[4] = srcRect.Right / fullsrcW; arr[5] = srcRect.Bottom / fullsrcH;
//arr[6] = 0; arr[7] = 0;
arr[6] = srcRect.Left / fullsrcW; arr[7] = srcRect.Bottom / fullsrcH;
}
GL.TexCoordPointer(2, TexCoordPointerType.Float, 0, (IntPtr)arr);
//------------------------------------------
//fill rect with texture
FillRectWithTexture(destRect.X, destRect.Y, destRect.Width, destRect.Height);
}
}
}
GL.DisableClientState(ArrayCap.TextureCoordArray);
}
GL.Disable(EnableCap.Texture2D);
this.StrokeColor = prevColor;
}
//enable color again
////at this point alpha component is fill in to destination
////-------------------------------------------------------------------------------------
////2. then fill again!,
////we use alpha information from dest,
////so we set blend func to ... GL.BlendFunc(BlendingFactorSrc.DstAlpha, BlendingFactorDest.OneMinusDstAlpha)
GL.ColorMask(true, true, true, true);
GL.BlendFunc(BlendingFactorSrc.DstAlpha, BlendingFactorDest.OneMinusDstAlpha);
{
int len = destAndSrcPairs.Length;
if (len > 1)
{
for (int i = 0; i < len;)
{
//each
var destRect = destAndSrcPairs[i];
var srcRect = destAndSrcPairs[i + 1];
i += 2;
FillRect(color, destRect.X, destRect.Y, destRect.Width, destRect.Height);
}
}
}
//3.
//set blend mode back
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
//fill with color
}
static unsafe void UnsafeDrawV2fList(DrawMode mode, float *polygon2dVertices, int vertexCount, PixelFarm.Drawing.Color c)
{
GL.Color4(c.R, c.G, c.B, c.A);
//1. enable client side memory
GL.EnableClientState(ArrayCap.VertexArray); //***
//2. load data from point to vertex array part
GL.VertexPointer(2, VertexPointerType.Float, 0, (IntPtr)polygon2dVertices);
//3. draw array
GL.DrawArrays((BeginMode)mode, 0, vertexCount);
//4. disable client side memory
GL.DisableClientState(ArrayCap.VertexArray);
}
public void SetColorValue(PixelFarm.Drawing.Color color)
{
_evaluatedAs = CssValueEvaluatedAs.Color;
_cachedColor = color;
}
/// <summary>
/// Check if the given color is visible if painted (has alpha and color values)
/// </summary>
/// <param name="color">the color to check</param>
/// <returns>true - visible, false - not visible</returns>
public static bool IsColorVisible(Color color)
{
return color.A > 0;
}
void SubPixRender(IImageReaderWriter dest, Scanline scanline, Color color)
{
byte[] covers = scanline.GetCovers();
int num_spans = scanline.SpanCount;
int y = scanline.Y;
byte[] buffer = dest.GetBuffer();
IPixelBlender blender = dest.GetRecieveBlender();
int last_x = int.MinValue;
int bufferOffset = 0;
//------------------------------------------
Color bgColor = Color.White;
float cb_R = bgColor.R / 255f;
float cb_G = bgColor.G / 255f;
float cb_B = bgColor.B / 255f;
float cf_R = color.R / 255f;
float cf_G = color.G / 255f;
float cf_B = color.B / 255f;
//------------------------------------------
int prevCover = -1;
for (int i = 1; i <= num_spans; ++i)
{
//render span by span
ScanlineSpan span = scanline.GetSpan(i);
if (span.x != last_x + 1)
{
bufferOffset = dest.GetBufferOffsetXY(span.x, y);
}
last_x = span.x;
int num_pix = span.len;
if (num_pix < 0)
{
//special encode***
num_pix = -num_pix; //make it positive value
last_x += (num_pix - 1);
//long span with coverage
int coverageValue = covers[span.cover_index];
//-------------------------------------------
if (coverageValue >= 255)
{
//100% cover
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
Color todrawColor = Color.FromArgb(a, Color.FromArgb(color.R, color.G, color.B));
while (num_pix > 0)
{
blender.BlendPixel(buffer, bufferOffset, todrawColor);
bufferOffset += 4; //1 pixel 4 bytes
--num_pix;
}
}
else
{
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
Color newc = Color.FromArgb(color.R, color.G, color.B);
Color todrawColor = Color.FromArgb(a, newc);
while (num_pix > 0)
{
blender.BlendPixel(buffer, bufferOffset, todrawColor);
bufferOffset += 4; //1 pixel 4 bytes
--num_pix;
}
}
prevCover = coverageValue;
}
else
{
int coverIndex = span.cover_index;
last_x += (num_pix - 1);
while (num_pix > 0)
{
int coverageValue = covers[coverIndex++];
if (coverageValue >= 255)
{
//100% cover
Color newc = Color.FromArgb(color.R, color.G, color.B);
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, Color.FromArgb(a, newc));
prevCover = coverageValue;
}
else
{
//check direction :
bool isUpHill = coverageValue >= prevCover;
//if (isUpHill != ((coverageValue % 2) > 0))
//{
//}
//----------------------------
byte c_r = 0, c_g = 0, c_b = 0;
//----------------------------
//assume lcd screen is RGB
float subpix_percent = ((float)(coverageValue) / 256f);
if (coverageValue < cover_1_3)
{
//assume LCD color arrangement is BGR
if (isUpHill)
{
c_r = bgColor.R;
c_g = bgColor.G;
c_b = (byte)(mix(cb_B, cf_B, subpix_percent) * 255);
}
else
{
c_r = (byte)(mix(cb_R, cf_R, subpix_percent) * 255);
c_g = bgColor.G;
c_b = bgColor.B;
}
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, Color.FromArgb(a, Color.FromArgb(c_r, c_g, c_b)));
}
else if (coverageValue < cover_2_3)
{
if (isUpHill)
{
c_r = bgColor.R;
c_g = (byte)(mix(cb_G, cf_G, subpix_percent) * 255);
c_b = (byte)(mix(cb_B, cf_B, 1) * 255);
}
else
{
c_r = (byte)(mix(cb_R, cf_R, 1) * 255);
c_g = (byte)(mix(cb_G, cf_G, subpix_percent) * 255);
c_b = bgColor.B;
}
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, Color.FromArgb(a, Color.FromArgb(c_r, c_g, c_b)));
}
else
{
//cover > 2/3 but not full
if (isUpHill)
{
c_r = (byte)(mix(cb_R, cf_R, subpix_percent) * 255);
c_g = (byte)(mix(cb_G, cf_G, 1) * 255);
c_b = (byte)(mix(cb_B, cf_B, 1) * 255);
}
else
{
c_r = (byte)(mix(cb_R, cf_R, 1) * 255);
c_g = (byte)(mix(cb_G, cf_G, 1) * 255);
c_b = (byte)(mix(cb_B, cf_B, subpix_percent) * 255);
}
int a = ((coverageValue + 1) * color.Alpha0To255) >> 8;
blender.BlendPixel(buffer, bufferOffset, Color.FromArgb(a, Color.FromArgb(c_r, c_g, c_b)));
}
}
bufferOffset += 4; //1 pixel 4 bits
--num_pix;
prevCover = coverageValue;
}
}
}
}
public void SetColors(Color c1, Color c2)
{
SetColors(c1, c2, 256);
}
public abstract void Rectangle(double left, double bottom, double right, double top, Color color);
public abstract void PaintSeries(VertexStore vxs, Color[] colors, int[] pathIndexs, int numPath);
public override void CopyVL(int x, int y,
int len,
Color c)
{
linkedImage.CopyHL(y, x, len, c);
}
public static void GetInterpolatedColor(Color[] colors, double x, double y,
out PixelFarm.Drawing.Color outputColor)
{
//interpolate by channel
double v1, v2, v3, v4, v;
byte a;
{
//row
v1 = getValue2(colors[0].A, colors[1].A, colors[2].A, colors[3].A, x);
v2 = getValue2(colors[4].A, colors[5].A, colors[6].A, colors[7].A, x);
v3 = getValue2(colors[8].A, colors[9].A, colors[10].A, colors[11].A, x);
v4 = getValue2(colors[12].A, colors[13].A, colors[14].A, colors[15].A, x);
//columns
v = getValue2(v1, v2, v3, v4, y);
//clamp
if (v > 255)
{
a = 255;
}
else if (v < 0)
{
a = 0;
}
else
{
a = (byte)v;
}
}
//---------------------------------------------------
byte r;
{
//row
v1 = getValue2(colors[0].R, colors[1].R, colors[2].R, colors[3].R, x);
v2 = getValue2(colors[4].R, colors[5].R, colors[6].R, colors[7].R, x);
v3 = getValue2(colors[8].R, colors[9].R, colors[10].R, colors[11].R, x);
v4 = getValue2(colors[12].R, colors[13].R, colors[14].R, colors[15].R, x);
//columns
v = getValue2(v1, v2, v3, v4, y);
//clamp
if (v > 255)
{
r = 255;
}
else if (v < 0)
{
r = 0;
}
else
{
r = (byte)v;
}
}
//---------------------------------------------------
byte g;
{
//row
v1 = getValue2(colors[0].G, colors[1].G, colors[2].G, colors[3].G, x);
v2 = getValue2(colors[4].G, colors[5].G, colors[6].G, colors[7].G, x);
v3 = getValue2(colors[8].G, colors[9].G, colors[10].G, colors[11].G, x);
v4 = getValue2(colors[12].G, colors[13].G, colors[14].G, colors[15].G, x);
//columns
v = getValue2(v1, v2, v3, v4, y);
//clamp
if (v > 255)
{
g = 255;
}
else if (v < 0)
{
g = 0;
}
else
{
g = (byte)v;
}
}
//---------------------------------------------------
byte b;
{
//b
v1 = getValue2(colors[0].B, colors[1].B, colors[2].B, colors[3].B, x);
v2 = getValue2(colors[4].B, colors[5].B, colors[6].B, colors[7].B, x);
v3 = getValue2(colors[8].B, colors[9].B, colors[10].B, colors[11].B, x);
v4 = getValue2(colors[12].B, colors[13].B, colors[14].B, colors[15].B, x);
//columns
v = getValue2(v1, v2, v3, v4, y);
//clamp
if (v > 255)
{
b = 255;
}
else if (v < 0)
{
b = 0;
}
else
{
b = (byte)v;
}
}
outputColor = new Color(a, r, g, b);
}
public override void BlendVL(int x, int y1, int y2, Color c, byte cover)
{
linkedImage.BlendHL(y1, x, y2, c, cover);
}
void BlendWithLcdTechnique(ActualImage destImg, ActualImage glyphImg, PixelFarm.Drawing.Color color)
{
//var g8Lut = g8_4_2_1;
//var forwardBuffer = new ScanlineSubPixelRasterizer.TempForwardAccumBuffer();
//int glyphH = glyphImg.Height;
//int glyphW = glyphImg.Width;
//byte[] glyphBuffer = ActualImage.GetBuffer(glyphImg);
//int srcIndex = 0;
//int srcStride = glyphImg.Stride;
//byte[] destImgBuffer = ActualImage.GetBuffer(destImg);
////start pixel
//int destImgIndex = 0;
//int destX = 0;
//byte[] rgb = new byte[]{
// color.R,
// color.G,
// color.B
//};
//byte color_a = color.alpha;
//for (int y = 0; y < glyphH; ++y)
//{
// srcIndex = srcStride * y;
// destImgIndex = (destImg.Stride * y) + (destX * 4); //4 color component
// int i = 0;
// int round = 0;
// forwardBuffer.Reset();
// byte e0 = 0;
// int prev_a = 0;
// for (int x = 0; x < glyphW; ++x)
// {
// //1.
// //read 1 pixel (4 bytes, 4 color components)
// byte r = glyphBuffer[srcIndex];
// byte g = glyphBuffer[srcIndex + 1];
// byte b = glyphBuffer[srcIndex + 2];
// byte a = glyphBuffer[srcIndex + 3];
// //2.
// //convert to grey scale and convert to 65 level grey scale value
// byte greyScaleValue = g8Lut.Convert255ToLevel(a);
// for (int n = 0; n < 3; ++n)
// {
// forwardBuffer.WriteAccumAndReadBack(
// g8Lut.TertiaryFromLevel(greyScaleValue),
// g8Lut.SecondaryFromLevel(greyScaleValue),
// g8Lut.PrimaryFromLevel(greyScaleValue), out e0);
// //5. blend this pixel to dest image (expand to 5 (sub)pixel)
// BlendPixel(e0 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// }
// //------------------------------------------------------------
// prev_a = a;
// srcIndex += 4;
// }
// //---------
// //when finish each line
// //we must draw extened 4 pixels
// //---------
// {
// byte e1, e2, e3, e4;
// forwardBuffer.ReadRemaining4(out e1, out e2, out e3, out e4);
// int remainingEnergy = Math.Min(srcStride, 4);
// switch (remainingEnergy)
// {
// default: throw new NotSupportedException();
// case 4:
// BlendPixel(e1 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// BlendPixel(e2 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// BlendPixel(e3 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// BlendPixel(e4 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// break;
// case 3:
// BlendPixel(e1 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// BlendPixel(e2 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// BlendPixel(e3 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// break;
// case 2:
// BlendPixel(e1 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// BlendPixel(e2 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// break;
// case 1:
// BlendPixel(e1 * color_a, rgb, ref i, destImgBuffer, ref destImgIndex, ref round);
// break;
// case 0:
// //nothing
// break;
// }
// }
//}
}
public override void CopyColorVSpan(int x, int y, int len, Color[] colors, int colorsIndex)
{
linkedImage.CopyColorHSpan(y, x, len, colors, colorsIndex);
}
//------------------------------------------------------- public abstract void Clear(Color color);
public static void ReadColorDataFromStream(BinaryReader reader, out Color[] colors)
{
int len = reader.ReadInt32();
colors = new Color[len];
for (int i = 0; i < len; ++i)
{
byte r = reader.ReadByte();
byte g = reader.ReadByte();
byte b = reader.ReadByte();
byte a = reader.ReadByte();
colors[i] = new Color(a, r, g, b);
}
int end = reader.ReadInt32();
}
public void FillCircle(PixelFarm.Drawing.Color color, float x, float y, float radius)
{
FillEllipse(color, x, y, radius, radius);
}
public abstract void FillCircle(double x, double y, double radius, Color color);
public abstract void FillRectangle(double left, double bottom, double right, double top, Color fillColor);
public void SetColors(Color c1, Color c2, int gradientSteps)
{
m_c1 = c1;
m_c2 = c2;
this.gradientSteps = gradientSteps;
}
public void RenderWithColor(IImageReaderWriter dest,
ScanlineRasterizer sclineRas,
Scanline scline,
Color color)
{
if (!sclineRas.RewindScanlines()) { return; } //early exit
//-----------------------------------------------
scline.ResetSpans(sclineRas.MinX, sclineRas.MaxX);
switch (this.ScanlineRenderMode)
{
default:
{
//prev mode
//this mode
while (sclineRas.SweepScanline(scline))
{
//render solid single scanline
int y = scline.Y;
int num_spans = scline.SpanCount;
byte[] covers = scline.GetCovers();
//render each span in the scanline
for (int i = 1; i <= num_spans; ++i)
{
ScanlineSpan span = scline.GetSpan(i);
if (span.len > 0)
{
//positive len
dest.BlendSolidHSpan(span.x, y, span.len, color, covers, span.cover_index);
}
else
{
//fill the line, same coverage area
int x = span.x;
int x2 = (x - span.len - 1);
dest.BlendHL(x, y, x2, color, covers[span.cover_index]);
}
}
}
}
break;
case Agg.ScanlineRenderMode.SubPixelRendering:
{
#if DEBUG
int dbugMinScanlineCount = 0;
#endif
while (sclineRas.SweepScanline(scline))
{
SubPixRender(dest, scline, color);
#if DEBUG
dbugMinScanlineCount++;
#endif
}
}
break;
case Agg.ScanlineRenderMode.Custom:
{
while (sclineRas.SweepScanline(scline))
{
CustomRenderSingleScanLine(dest, scline, color);
}
}
break;
}
}
public void DrawMarker(float x, float y, PixelFarm.Drawing.Color color, float sizeInPx = 8)
{
painter.FillRect(x, y, sizeInPx, sizeInPx, color);
}
void CreateChromaTestButtons(AppHost host, int x, int y)
{
void ShowColorBoxs(Box colorBoxPanel, PixelFarm.Drawing.Color[] colors)
{
//nested method
colorBoxPanel.ClearChildren();
for (int i = 0; i < colors.Length; ++i)
{
Box colorBox = new Box(30, 30);
PixelFarm.Drawing.Color c = colors[i];
colorBox.BackColor = new PixelFarm.Drawing.Color(c.R, c.G, c.B);
colorBoxPanel.Add(colorBox);
}
UI.LayoutUpdateArgs updateArgs = new UI.LayoutUpdateArgs();
colorBoxPanel.PerformContentLayout(updateArgs);
}
Box colorPanel = new Box(200, 40);
colorPanel.ContentLayoutKind = BoxContentLayoutKind.HorizontalStack;
colorPanel.BackColor = PixelFarm.Drawing.Color.White;
colorPanel.SetLocation(x, y);
host.AddChild(colorPanel);
y += colorPanel.Height;
//test1...
var buttonBeh = new UI.UIMouseBehaviour <Label, object>();
buttonBeh.MouseMove += (s, e) =>
{
if (e.CurrentContextElement is Label lbl)
{
lbl.BackColor = PixelFarm.Drawing.Color.Yellow;
}
};
buttonBeh.MouseLeave += (s, e) =>
{
if (e.CurrentContextElement is Label lbl)
{
lbl.BackColor = PixelFarm.Drawing.KnownColors.Gray;
}
};
//----------------------------------
{
Label lblChromaDarken = new Label();
lblChromaDarken.BackColor = PixelFarm.Drawing.KnownColors.Gray;
lblChromaDarken.Text = "Darken";
lblChromaDarken.SetLocation(x, y);
buttonBeh.AttachSharedBehaviorTo(lblChromaDarken);
UI.GeneralEventListener evListener = new UI.GeneralEventListener();
evListener.MouseDown += (s, e) =>
{
PixelFarm.Drawing.Color color = PixelFarm.Drawing.KnownColors.DeepPink;
using (Tools.More.BorrowChromaTool(out var chroma))
{
chroma.SetColor(color);
PixelFarm.Drawing.Color[] colors = new[] {
color,
chroma.Darken(),
chroma.Darken(2),
chroma.Darken(2.6)
};
//present in the box
ShowColorBoxs(colorPanel, colors);
}
};
lblChromaDarken.AttachExternalEventListener(evListener);
x += 50;
host.AddChild(lblChromaDarken);
}
//----------------------------------
{
Label lblLighten = new Label();
lblLighten.Text = "Brighten";
buttonBeh.AttachSharedBehaviorTo(lblLighten);
lblLighten.SetLocation(x, y);
{
UI.GeneralEventListener evListener = new UI.GeneralEventListener();
evListener.MouseDown += (s, e) =>
{
PixelFarm.Drawing.Color color = PixelFarm.Drawing.KnownColors.DeepPink;
using (Tools.More.BorrowChromaTool(out var chroma))
{
chroma.SetColor(color);
PixelFarm.Drawing.Color[] colors = new[] {
color,
chroma.Brighten(),
chroma.Brighten(2),
chroma.Brighten(3)
};
//present in the box
ShowColorBoxs(colorPanel, colors);
}
};
lblLighten.AttachExternalEventListener(evListener);
}
x += lblLighten.Width + 5;
host.AddChild(lblLighten);
}
}
void CreateRBGVarBoxes(AppHost host, int x, int y)
{
_rgb_varBoxes = new Box[7];
for (int i = 0; i < 7; ++i)
{
Box rgb_varBox = new Box(40, 40);
rgb_varBox.SetLocation(x + (i * 40), y);
_rgb_varBoxes[i] = rgb_varBox;
host.AddChild(rgb_varBox);
}
}
void CreateSwatchBoxes(AppHost host, int x, int y)
{
_swatch_Boxes = new Box[6];
for (int i = 0; i < 6; ++i)
{
Box swatchBox = new Box(40, 40);
swatchBox.SetLocation(x + (i * 40), y);
_swatch_Boxes[i] = swatchBox;
host.AddChild(swatchBox);
}
}
void CreateHsvVarBoxes(AppHost host, int x, int y)
{
_hsv_varBoxes = new Box[9];
for (int i = 0; i < 9; ++i)
{
Box hsv_varBox = new Box(40, 40);
hsv_varBox.SetLocation(x + (i * 40), y);
_hsv_varBoxes[i] = hsv_varBox;
host.AddChild(hsv_varBox);
}
}
void CreateRBGScrollBarAndSampleColorBox(
int x, int y,
out ScrollBar scBar,
out Box sampleBox,
Action <ScrollBar, Box> pairAction
)
{
//Action<>
//horizontal scrollbar
scBar = new LayoutFarm.CustomWidgets.ScrollBar(300, 15);
//TODO: add mx with layout engine
scBar.ScrollBarType = CustomWidgets.ScrollBarType.Horizontal;
scBar.SetLocation(x, y);
scBar.MinValue = 0;
scBar.MaxValue = 255 * 10;
scBar.SmallChange = 1;
//
scBar.ScrollValue = 0; //init
//
sampleBox = new Box(30, 30);
sampleBox.SetLocation(x + 350, y);
//
var n_scBar = scBar;
var n_sampleBox = sampleBox;
scBar.SliderBox.UserScroll += (s, e) => pairAction(n_scBar, n_sampleBox);
pairAction(n_scBar, n_sampleBox);
}
bool _component_ready = false;
void UpdateAllComponents()
{
byte r = (byte)(_r_sc.ScrollValue / 10);
byte g = (byte)(_g_sc.ScrollValue / 10);
byte b = (byte)(_b_sc.ScrollValue / 10);
_pure_rgbBox.BackColor = new PixelFarm.Drawing.Color(r, g, b);
//the update ColorMatch
_colorMatch.CurrentAlgorithm = _blenderAlgo;
_colorMatch.CurrentRGB = new RGB(r, g, b);
_colorMatch.CurrentHSV = _colorMatch.CurrentRGB.ToHSV();
_colorMatch.CurrentRGB = _colorMatch.CurrentHSV.ToRGB();//?
_colorMatch.Update();
//then present color match results
//1. rgb variants
for (int i = 0; i < 7; ++i)
{
_rgb_varBoxes[i].BackColor = _colorMatch.VariationsRGB[i].ToPixelFarmColor();
}
//2. hsv variants
for (int i = 0; i < 9; ++i)
{
_hsv_varBoxes[i].BackColor = _colorMatch.VariationsHSV[i].ToPixelFarmColor();
}
//3. swatch box
Blend blend = _colorMatch.CurrentBlend;
for (int i = 0; i < 6; ++i)
{
_swatch_Boxes[i].BackColor = blend.Colors[i].ToRGB().ToPixelFarmColor();
}
}
}
