public VxsTextPrinter(CanvasPainter canvasPainter, IFontLoader fontLoader)
{
this.canvasPainter = canvasPainter;
this._fontLoader = fontLoader;
this.ScriptLang = canvasPainter.CurrentFont.GetOpenFontScriptLang();
ChangeFont(canvasPainter.CurrentFont);
}
public override void DrawCaret(float x, float y)
{
CanvasPainter p = this.TargetCanvasPainter;
PixelFarm.Drawing.Color prevColor = p.StrokeColor;
p.StrokeColor = PixelFarm.Drawing.Color.Red;
p.Line(x, y, x, y + this.FontAscendingPx);
p.StrokeColor = prevColor;
}
public MiniAggCanvasRenderElement(RootGraphic rootgfx, int width, int height)
: base(rootgfx, width, height)
{
this.actualImage = new ActualImage(width, height, PixelFarm.Agg.PixelFormat.ARGB32);
this.gfx2d = Graphics2D.CreateFromImage(actualImage);
this.painter = new AggCanvasPainter((ImageGraphics2D)gfx2d);
needUpdate = true;
this.BackColor = Color.White;
}
public VxsTextPrinter(CanvasPainter canvasPainter, IFontLoader fontLoader)
{
this.canvasPainter = canvasPainter;
this._fontLoader = fontLoader;
_glyphMeshStore = new GlyphMeshStore();
//
_pxScaleEngine = new PixelScaleLayoutEngine();
_pxScaleEngine.HintedFontStore = _glyphMeshStore;//share _glyphMeshStore with pixel-scale-layout-engine
}
public override void Draw(CanvasPainter p)
{
p.Clear(ColorRGBA.White);
//g.UseSubPixelRendering = true;
string teststr = "ABCDE abcd 1230 Hello!";
p.DrawString(teststr, 300, 400);
//g.UseSubPixelRendering = false;
//g.DrawString(teststr, 300, 422, 22);
}
public static void PaintPicture(CanvasPainter painter)
{
Triangle triangle = new Triangle(new Point(10, 15), new Point(100, 200), new Point(150, 250));
Rectangle rectangle = new Rectangle(new Point(30, 40), 18, 24, 0x6B8E23);
Console.WriteLine("Triangle:");
painter.Draw(triangle);
Console.WriteLine("Rectangle:");
painter.Draw(rectangle);
}
private void PaintPicture(CanvasPainter painter)
{
var triangle = new Triangle(new Point(10, 15), new Point(100, 200), new Point(150, 250));
var rectangle = new Rectangle(new Point(30, 40), 18, 24);
Console.WriteLine("---------triangle--------");
painter.Draw(triangle);
Console.WriteLine("---------rectangle--------");
painter.Draw(rectangle);
}
void RunSampleC(CanvasPainter p)
{
//version 3:
p.Clear(PixelFarm.Drawing.Color.White);
//---------------------------------------------
p.StrokeColor = PixelFarm.Drawing.Color.Black;
p.StrokeWidth = 1.0f;
p.UseSubPixelRendering = true;
p.Line(0, 0, 15, 20);
}
private void PaintPicture(CanvasPainter painter)
{
var triangle = new Triangle(new Point(10, 15), new Point(100, 200), new Point(150, 250), (uint)Color.Black.ToArgb());
var rectangle = new RectangeShape(new Point(30, 40), 18, 24, (uint)Color.Coral.ToArgb());
Console.WriteLine("---------triangle--------");
painter.Draw(triangle);
Console.WriteLine("---------rectangle--------");
painter.Draw(rectangle);
}
public override void Draw(CanvasPainter p)
{
p.Clear(Color.White);
if (BackgroundColor.Alpha0To255 > 0)
{
p.FillColor = BackgroundColor;
p.FillRectangle(0, 0, this.Width, Height);
}
render_gpc(p);
}
static void DrawLineSet(CanvasPainter p, List <Point> contPoints)
{
int pcount = contPoints.Count;
for (int i = 1; i < pcount; ++i)
{
var p0 = contPoints[i - 1];
var p1 = contPoints[i];
p.Line(p0.x, p0.y, p1.x, p1.y);
}
}
public override void Draw(CanvasPainter p)
{
p.DrawImage(actualImage, 0, 0);
p.DrawImage(actualImage,
AffinePlan.Translate(actualImage.Width * 2, actualImage.Height * 2),
AffinePlan.Scale(0.5));
p.FillColor = Drawing.Color.Blue;
p.FillRectangle(0, 0, 5, 5);
p.FillColor = Drawing.Color.Green;
p.FillRectangle(actualImage.Width, actualImage.Height,
actualImage.Width + 5, actualImage.Height + 5);
}
public override void Draw(CanvasPainter p)
{
p.Clear(Drawing.Color.White);
//g.UseSubPixelRendering = true;
string teststr = "ABCDE abcd 1230 Hello!";
//string teststr = "A";
p.FillColor = PixelFarm.Drawing.Color.Black;
p.DrawString(teststr, 300, 400);
//g.UseSubPixelRendering = false;
//g.DrawString(teststr, 300, 422, 22);
}
static void DrawLion(CanvasPainter p, SpriteShape shape, VertexStore myvxs)
{
int j = shape.NumPaths;
int[] pathList = shape.PathIndexList;
Color[] colors = shape.Colors;
for (int i = 0; i < j; ++i)
{
p.FillColor = colors[i];
p.Fill(new VertexStoreSnap(myvxs, pathList[i]));
}
}
public override void Draw(Graphics2D g)
{
if (p == null)
{
p = new CanvasPainter(g);
p.StrokeColor = ColorRGBA.Black;
p.StrokeWidth = 1;
}
p.Clear(ColorRGBA.White);
p.FillColor = ColorRGBA.Black;
int j = myBrushPathList.Count;
for (int n = 0; n < j; ++n)
{
var brushPath = myBrushPathList[n];
if (brushPath.vxs != null)
{
switch (brushPath.BrushMode)
{
case SmoothBrushMode.CutBrush:
{
} break;
default:
{
p.FillColor = brushPath.FillColor;
p.Fill(brushPath.vxs);
if (brushPath.StrokeColor.alpha > 0)
{
p.StrokeColor = ColorRGBA.Red;
p.Draw(brushPath.vxs);
}
} break;
}
}
else
{
var contPoints = brushPath.contPoints;
int pcount = contPoints.Count;
for (int i = 1; i < pcount; ++i)
{
var p0 = contPoints[i - 1];
var p1 = contPoints[i];
p.Line(p0.x, p0.y, p1.x, p1.y);
}
}
}
}
public override void Draw(CanvasPainter p)
{
//-----------------------------------------------------------------
//control
CanvasPainter painter = p;
painter.Clear(this.WhiteOnBlack ? ColorRGBA.Black : ColorRGBA.White);
painter.FillColor = new ColorRGBA(127, 127, 127);
painter.FillCircle(m_x[0], m_y[0], 3); //left-bottom control box
painter.FillCircle(m_x[1], m_y[1], 3); //right-top control box
//-----------------------------------------------------------------
double d = this.SubPixelOffset;
AggCanvasPainter p2 = p as AggCanvasPainter;
IPixelBlender prevBlender = null;
Graphics2D gx = null;
if (p2 != null)
{
//for agg only
gx = p2.Graphics;
prevBlender = gx.PixelBlender;
//change gamma blender
gx.PixelBlender = new PixelBlenderGammaBGRA(this.Gamma);
}
if (this.FillRoundRect)
{
painter.FillColor = this.WhiteOnBlack ? ColorRGBA.White : ColorRGBA.Black;
painter.FillRoundRectangle(
m_x[0] + d,
m_y[0] + d,
m_x[1] + d,
m_y[1] + d,
this.Radius);
}
else
{
painter.StrokeColor = this.WhiteOnBlack ? ColorRGBA.White : ColorRGBA.Black;
painter.DrawRoundRect(
m_x[0] + d,
m_y[0] + d,
m_x[1] + d,
m_y[1] + d,
this.Radius);
}
if (gx != null)
{
gx.PixelBlender = prevBlender;
}
}
public override void Draw(CanvasPainter p)
{
//specific for agg
if (p is PixelFarm.Agg.AggCanvasPainter)
{
var p2 = (PixelFarm.Agg.AggCanvasPainter)p;
Graphics2D gx = p2.Graphics;
var widgetsSubImage = ImageHelper.CreateChildImage(gx.DestImage, gx.GetClippingRect());
gx.UseSubPixelRendering = false;
IPixelBlender NormalBlender = new PixelBlenderBGRA();
IPixelBlender GammaBlender = new PixelBlenderGammaBGRA(this.GammaValue);
var rasterGamma = new ChildImage(widgetsSubImage, GammaBlender);
ClipProxyImage clippingProxyNormal = new ClipProxyImage(widgetsSubImage);
ClipProxyImage clippingProxyGamma = new ClipProxyImage(rasterGamma);
clippingProxyNormal.Clear(Color.White);
var rasterizer = gx.ScanlineRasterizer;
ScanlineUnpacked8 sl = new ScanlineUnpacked8();
int size_mul = (int)this.PixelSize;
CustomScanlineRasToBmp_EnlargedSubPixelRendering ren_en = new CustomScanlineRasToBmp_EnlargedSubPixelRendering(size_mul, gx.DestActualImage);
rasterizer.Reset();
rasterizer.MoveTo(m_x[0] / size_mul, m_y[0] / size_mul);
rasterizer.LineTo(m_x[1] / size_mul, m_y[1] / size_mul);
rasterizer.LineTo(m_x[2] / size_mul, m_y[2] / size_mul);
ren_en.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
//----------------------------------------
ScanlineRasToDestBitmapRenderer sclineRasToBmp = gx.ScanlineRasToDestBitmap;
gx.UseSubPixelRendering = true;
sclineRasToBmp.RenderWithColor(clippingProxyGamma, rasterizer, sl, Color.Black);
rasterizer.ResetGamma(new GammaNone());
gx.UseSubPixelRendering = false;
//----------------------------------------
PathWriter ps = new PathWriter();
ps.Clear();
ps.MoveTo(m_x[0], m_y[0]);
ps.LineTo(m_x[1], m_y[1]);
ps.LineTo(m_x[2], m_y[2]);
ps.LineTo(m_x[0], m_y[0]);
//----------------------------------------
//Stroke stroke = new Stroke(ps);
//stroke.Width = 2;
//rasterizer.AddPath(stroke.MakeVxs(ps.MakeVxs()));
var v1 = GetFreeVxs();
rasterizer.AddPath(stroke.MakeVxs(ps.Vxs, v1));
ReleaseVxs(ref v1);
//----------------------------------------
sclineRasToBmp.RenderWithColor(clippingProxyNormal, rasterizer, sl, new Color(200, 0, 150, 160));
}
}
public override void DrawGlyphPlanList(List <GlyphPlan> glyphPlanList, int startAt, int len, float xpos, float ypos)
{
CanvasPainter canvasPainter = this.TargetCanvasPainter;
Typeface typeface = _glyphPathBuilder.Typeface;
//3. layout glyphs with selected layout technique
//TODO: review this again, we should use pixel?
float fontSizePoint = this.FontSizeInPoints;
float scale = typeface.CalculateFromPointToPixelScale(fontSizePoint);
//4. render each glyph
float ox = canvasPainter.OriginX;
float oy = canvasPainter.OriginY;
int endBefore = startAt + len;
//---------------------------------------------------
//consider use cached glyph, to increase performance
hintGlyphCollection.SetCacheInfo(typeface, fontSizePoint, this.HintTechnique);
//---------------------------------------------------
for (int i = startAt; i < endBefore; ++i)
{
GlyphPlan glyphPlan = glyphPlanList[i];
//-----------------------------------
//TODO: review here ***
//PERFORMANCE revisit here
//if we have create a vxs we can cache it for later use?
//-----------------------------------
VertexStore glyphVxs;
if (!hintGlyphCollection.TryGetCacheGlyph(glyphPlan.glyphIndex, out glyphVxs))
{
//if not found then create new glyph vxs and cache it
_glyphPathBuilder.BuildFromGlyphIndex(glyphPlan.glyphIndex, fontSizePoint);
//-----------------------------------
_tovxs.Reset();
_glyphPathBuilder.ReadShapes(_tovxs);
//TODO: review here,
//float pxScale = _glyphPathBuilder.GetPixelScale();
glyphVxs = new VertexStore();
_tovxs.WriteOutput(glyphVxs, _vxsPool);
//
hintGlyphCollection.RegisterCachedGlyph(glyphPlan.glyphIndex, glyphVxs);
}
canvasPainter.SetOrigin((float)(glyphPlan.x * scale + xpos), (float)(glyphPlan.y * scale + ypos));
canvasPainter.Fill(glyphVxs);
}
//restore prev origin
canvasPainter.SetOrigin(ox, oy);
}
public override void Draw(Graphics2D g)
{
if (p == null)
{
p = new CanvasPainter(g);
p.StrokeColor = ColorRGBA.Black;
p.StrokeWidth = 1;
}
p.Clear(ColorRGBA.White);
var plistCount = pointSets.Count;
p.StrokeColor = ColorRGBA.Black;
for (int n = 0; n < plistCount; ++n)
{
var contPoints = pointSets[n];
DrawLineSet(p, contPoints);
}
plistCount = simplifiedPointSets.Count;
p.StrokeColor = ColorRGBA.Red;
for (int n = 0; n < plistCount; ++n)
{
var contPoints = simplifiedPointSets[n];
DrawLineSet(p, contPoints);
}
p.StrokeColor = ColorRGBA.Blue;
p.FillColor = ColorRGBA.Black;
int ccount = cubicCurves.Count;
for (int i = 0; i < ccount; ++i)
{
var cc = cubicCurves[i];
FillPoint(cc.p0, p);
FillPoint(cc.p1, p);
FillPoint(cc.p2, p);
FillPoint(cc.p3, p);
p.DrawBezierCurve(
(float)cc.p0.x, (float)cc.p0.y,
(float)cc.p3.x, (float)cc.p3.y,
(float)cc.p1.x, (float)cc.p1.y,
(float)cc.p2.x, (float)cc.p2.y);
}
}
public void TestDrawCanvas()
{
Shape shape = ShapeFactory.GetCircle();
shape.pointOne.X = 10;
shape.pointOne.Y = 10;
shape.radius = 2;
Canvas canvas = new Canvas();
canvas.size = new string[10, 10];
canvas.shapeList = new List <Shape>();
canvas.shapeList.Add(shape);
CanvasPainter.CreateCanvas(canvas);
}
public void TestDrawCanvas()
{
Shape shape = ShapeFactory.GetRectangle();
shape.pointOne.X = 1;
shape.pointOne.Y = 1;
shape.pointTwo.X = 5;
shape.pointTwo.Y = 5;
Canvas canvas = new Canvas();
canvas.size = new string[10, 10];
canvas.shapeList = new List <Shape>();
canvas.shapeList.Add(shape);
CanvasPainter.CreateCanvas(canvas);
}
public void Print(CanvasPainter painter, char[] buffer, double x, double y)
{
int j = buffer.Length;
int buffsize = j * 2;
//get kerning list
ProperGlyph[] properGlyphs = new ProperGlyph[buffsize];
currentFont.GetGlyphPos(buffer, 0, buffsize, properGlyphs);
double xpos = x;
for (int i = 0; i < buffsize; ++i)
{
uint codepoint = properGlyphs[i].codepoint;
if (codepoint == 0)
{
break;
}
//-------------------------------------------------------------
FontGlyph glyph = this.currentFont.GetGlyphByIndex(codepoint);
var left = glyph.exportGlyph.img_horiBearingX;
//--------------------------------------------------------
//render with vector
//var mat = Agg.Transform.Affine.NewMatix(
//Agg.Transform.AffinePlan.Scale(0.30),
//Agg.Transform.AffinePlan.Translate(xpos, y));
//var vxs1 = mat.TransformToVxs(glyph.flattenVxs);
VertexStore vxs1 = Agg.Transform.Affine.TranslateToVxs(
glyph.flattenVxs,
(float)(xpos),
(float)(y));
painter.Fill(vxs1);
//--------------------------------------------------------
////render with bitmap
//this.painter.DrawImage(glyph.glyphImage32,
// (float)(xpos + (left >> 6)),
// (float)(y + (glyph.exportGlyph.bboxYmin >> 6)));
int w = (glyph.exportGlyph.advanceX) >> 6;
xpos += (w);
//-------------------------------------------------------------
}
}
public VxsTextPrinter(CanvasPainter canvasPainter)
{
this.canvasPainter = canvasPainter;
RequestFont font = canvasPainter.CurrentFont;
Typography.OpenFont.ScriptLang scLang = Typography.OpenFont.ScriptLangs.GetRegisteredScriptLang(font.ScriptCode.shortname);
#if DEBUG
if (scLang == null)
{
throw new NotSupportedException("unknown script lang");
}
#endif
vxsTextPrinter.ScriptLang = scLang;
//1. resolve actual font file
vxsTextPrinter.FontFile = "d:\\WImageTest\\tahoma.ttf";
}
public override void Draw(CanvasPainter p)
{
p.FillColor = ColorRGBA.Blue;
p.FillRectangle(0, 70, 150, 120);
//-------------------------------------------
var innerGradient = new Gradients.GvcRadial();
SpanInterpolatorLinear linerInterpolator = new SpanInterpolatorLinear(Affine.IdentityMatrix);
LinearGradientColorsProvider linearColorProvider = new LinearGradientColorsProvider(ColorRGBA.Red, ColorRGBA.Yellow);
SpanGenGradient spanGenGradient = new SpanGenGradient(linerInterpolator,
innerGradient,
linearColorProvider,
0, 150);
SimpleRect srect = new SimpleRect(0, 0, 150, 50);
p.Fill(srect.MakeVxs(), spanGenGradient);
}
public static void PaintPictureOnMGRClassAdapter()
{
ClassAdapter classAdapter = new ClassAdapter(Console.Out);
CanvasPainter painter = new CanvasPainter(classAdapter);
try
{
classAdapter.BeginDraw();
PaintPicture(painter);
classAdapter.EndDraw();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
private void PaintPictureOnMGRendererClassAdapter()
{
var adapter = new MGRendererClassAdapter(Console.Out);
var painter = new CanvasPainter(adapter);
try
{
adapter.BeginDraw();
PaintPicture(painter);
adapter.EndDraw();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
void DrawBoneJoint(CanvasPainter painter, GlyphBoneJoint joint)
{
//--------------
EdgeLine p_contactEdge = joint.dbugGetEdge_P();
//mid point
Vector2 jointPos = joint.OriginalJointPos * _pxscale;//scaled joint pos
painter.FillRectLBWH(jointPos.X, jointPos.Y, 4, 4, PixelFarm.Drawing.Color.Yellow);
if (joint.TipEdgeP != null)
{
EdgeLine tipEdge = joint.TipEdgeP;
double p_x, p_y, q_x, q_y;
tipEdge.dbugGetScaledXY(out p_x, out p_y, out q_x, out q_y, _pxscale);
//
painter.Line(
jointPos.X, jointPos.Y,
p_x, p_y,
PixelFarm.Drawing.Color.White);
painter.FillRectLBWH(p_x, p_y, 3, 3, PixelFarm.Drawing.Color.Green); //marker
//
painter.Line(
jointPos.X, jointPos.Y,
q_x, q_y,
PixelFarm.Drawing.Color.White);
painter.FillRectLBWH(q_x, q_y, 3, 3, PixelFarm.Drawing.Color.Green); //marker
}
if (joint.TipEdgeQ != null)
{
EdgeLine tipEdge = joint.TipEdgeQ;
double p_x, p_y, q_x, q_y;
tipEdge.dbugGetScaledXY(out p_x, out p_y, out q_x, out q_y, _pxscale);
//
painter.Line(
jointPos.X, jointPos.Y,
p_x, p_y,
PixelFarm.Drawing.Color.White);
painter.FillRectLBWH(p_x, p_y, 3, 3, PixelFarm.Drawing.Color.Green); //marker
//
painter.Line(
jointPos.X, jointPos.Y,
q_x, q_y,
PixelFarm.Drawing.Color.White);
painter.FillRectLBWH(q_x, q_y, 3, 3, PixelFarm.Drawing.Color.Green); //marker
}
}
public override void Draw(CanvasPainter p)
{
p.Clear(Drawing.Color.White);
p.FillColor = Drawing.Color.Black;
int j = myBrushPathList.Count;
for (int n = 0; n < j; ++n)
{
var brushPath = myBrushPathList[n];
if (brushPath.Vxs != null)
{
switch (brushPath.BrushMode)
{
case SmoothBrushMode.CutBrush:
{
}
break;
default:
{
//TODO: review PixelCache here
p.FillColor = brushPath.FillColor;
p.Fill(brushPath.Vxs);
if (brushPath.StrokeColor.alpha > 0)
{
p.StrokeColor = Drawing.Color.Red;
p.Draw(brushPath.Vxs);
}
}
break;
}
}
else
{
//current drawing brush
var contPoints = brushPath.contPoints;
int pcount = contPoints.Count;
for (int i = 1; i < pcount; ++i)
{
var p0 = contPoints[i - 1];
var p1 = contPoints[i];
p.Line(p0.x, p0.y, p1.x, p1.y);
}
}
}
}
void RenderGrids(int width, int height, int sqSize, CanvasPainter p)
{
//render grid
p.FillColor = PixelFarm.Drawing.Color.Gray;
float pointW = (sqSize >= 100) ? 2 : 1;
for (int y = 0; y < height;)
{
for (int x = 0; x < width;)
{
p.FillRectLBWH(x, y, pointW, pointW);
x += sqSize;
}
y += sqSize;
}
}
public static void PaintPictureOnMGRObjectAdapter()
{
ModernGraphicsRenderer renderer = new ModernGraphicsRenderer(Console.Out);
ObjectAdapter objectAdapter = new ObjectAdapter(renderer);
CanvasPainter painter = new CanvasPainter(objectAdapter);
try
{
renderer.BeginDraw();
PaintPicture(painter);
renderer.EndDraw();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
