private void Start()
{
if (gameState == null)
{
gameState = new GameState(GameState.WHITE_TURN);
}
drawBoard = GameObject.Find("Draw Board").GetComponent <DrawBoard>();
turnDisplay = GameObject.FindGameObjectWithTag("Text").GetComponent <TextMeshProUGUI>();
promoteMenu = GameObject.FindGameObjectWithTag("PromoteMenu");
endGameMenu = GameObject.FindGameObjectWithTag("EndGame");
board = NetworkBoard.GetBoard;
pieces = NetworkBoard.GetPieces;
legalMovesForAPiece = new List <Vector2>();
//Initialize Movement Model
moveModel = GetComponent <NetworkMoveModel>();
capturedPieces = new List <Piece>();
//if (isLocalPlayer)
//promoteMenu.SetActive(false);
}
protected override void DrawBoxContent(DrawBoard canvas, Rectangle updateArea)
{
#if DEBUG
//if (this.dbugBreak)
//{
//}
#endif
//sample bg
//canvas.FillRectangle(BackColor, updateArea.Left, updateArea.Top, updateArea.Width, updateArea.Height);
canvas.FillRectangle(BackColor, 0, 0, this.Width, this.Height);
gridLayer.DrawChildContent(canvas, updateArea);
if (this.HasDefaultLayer)
{
this.DrawDefaultLayer(canvas, ref updateArea);
}
#if DEBUG
//canvas.dbug_DrawCrossRect(PixelFarm.Drawing.Color.Black,
// new Rectangle(0, 0, this.Width, this.Height));
//canvas.dbug_DrawCrossRect(PixelFarm.Drawing.Color.Black,
// new Rectangle(updateArea.Left, updateArea.Top, updateArea.Width, updateArea.Height));
#endif
}
public void TryGetHighestTripleTriomino_has_to_work()
{
DrawBoard drawBoard = new DrawBoard(PlayerCode.Player1);
Assert.IsTrue(drawBoard.TryAddTile("0-1-1"));
Assert.IsTrue(drawBoard.TryAddTile("0-1-2"));
Assert.IsTrue(drawBoard.TryAddTile("1-2-3"));
Assert.AreEqual(6, drawBoard.GetHighestTriominoValue());
Assert.IsFalse(drawBoard.TryGetHighestTripleTriomino(out string highestTripleTriomino));
Assert.IsNull(highestTripleTriomino);
Assert.IsTrue(drawBoard.TryAddTile("0-0-0"));
Assert.IsTrue(drawBoard.TryGetHighestTripleTriomino(out highestTripleTriomino));
Assert.AreEqual("0-0-0", highestTripleTriomino);
Assert.IsTrue(drawBoard.TryAddTile("1-1-1"));
Assert.IsTrue(drawBoard.TryAddTile("3-3-3"));
Assert.IsTrue(drawBoard.TryGetHighestTripleTriomino(out highestTripleTriomino));
Assert.AreEqual("3-3-3", highestTripleTriomino);
Assert.AreEqual(9, drawBoard.GetHighestTriominoValue());
}
void Awake()
{
legalMoves = GetComponent <LegalMoves>();
manager = GetComponent <GameManager>();
drawBoard = GetComponent <DrawBoard>();
ai = GetComponent <AI>();
analysisBoard = new Square[8, 8];
board = new Piece[8, 8];
for (int ranks = 0; ranks < 8; ranks++)
{
for (int files = 0; files < 8; files++)
{
board[files, ranks] = drawBoard.GetSquare(files, ranks);
board[files, ranks].piece = Pieces.Empty;
board[files, ranks].coordinates = new Coord(files, ranks);
}
}
SetupFromFEN(startFEN);
}
public override void CustomDrawToThisCanvas(DrawBoard canvas, Rectangle updateArea)
{
//draw line
//we can use vxs/path to render a complex line part
if (_stroke != null)
{
var savedSmoothingMode = canvas.SetSmoothMode(SmoothingMode.AntiAlias);
canvas.DrawRenderVx(_stroke, X0, Y0); //?
savedSmoothingMode.Restore(); //restore
}
else
{
float prevW = canvas.StrokeWidth; //save
var savedSmoothingMode = canvas.SetSmoothMode(SmoothingMode.AntiAlias);
canvas.StrokeWidth = 3;
canvas.DrawLine(X0, Y0, X1, Y1);
canvas.StrokeWidth = prevW;//restore
savedSmoothingMode.Restore();
}
}
public StrokeState(DrawBoard d)
{
_d = d;
_stokeColor = d.StrokeColor;
_strokeW = d.StrokeWidth;
}
internal SmoothingModeState(DrawBoard drawBoard, SmoothingMode state)
{
_latestSmoothMode = state;
_drawBoard = drawBoard;
}
public static StrokeState SaveStroke(this DrawBoard drawBoard)
{
return(new StrokeState(drawBoard));
}
//--------------------------------------------------
public static SmoothingModeState SaveSmoothMode(this DrawBoard drawBoard)
{
//TODO: review offset function
return(new SmoothingModeState(drawBoard, drawBoard.SmoothingMode));
}
/// <summary>
/// Draw specific border (top/bottom/left/right) with the box data (style/width/rounded).<br/>
/// </summary>
/// <param name="borderSide">desired border to draw</param>
/// <param name="box">the box to draw its borders, contain the borders data</param>
/// <param name="g">the device to draw into</param>
/// <param name="rect">the rectangle the border is enclosing</param>
/// <param name="isLineStart">Specifies if the border is for a starting line (no bevel on left)</param>
/// <param name="isLineEnd">Specifies if the border is for an ending line (no bevel on right)</param>
static void DrawBorder(CssSide borderSide, CssBox box,
PaintVisitor p, RectangleF rect, bool isLineStart, bool isLineEnd)
{
GetBorderBorderDrawingInfo(box, borderSide, out CssBorderStyle style, out Color borderColor, out float actualBorderWidth);
DrawBoard g = p.InnerDrawBoard;
if (box.HasSomeRoundCorner)
{
using (Tools.BorrowVxs(out var v1))
{
RenderUtils.WriteRoundRect(v1, rect, 2, 2, 2, 2);//temp
Painter pp = g.GetPainter();
pp.FillStroke(v1, actualBorderWidth, borderColor);
}
}
else
{
// non rounded border
switch (style)
{
case CssBorderStyle.Inset:
case CssBorderStyle.Outset:
{
// inset/outset border needs special rectangle
PointF[] borderPnts = new PointF[4];
SetInOutsetRectanglePoints(borderSide, box, rect, isLineStart, isLineEnd, borderPnts);
g.FillPolygon(borderColor, borderPnts);
}
break;
default:
{
// solid/dotted/dashed border draw as simple line
//using (var pen = GetPen(p.Platform, style, borderColor, actualBorderWidth))
//{
var prevColor = g.StrokeColor;
g.StrokeColor = borderColor;
float prevStrokeW = g.StrokeWidth;
g.StrokeWidth = actualBorderWidth;
//s_simpleRectBorderBuilder.SetBorderWidth(
// box.ActualBorderLeftWidth,
// box.ActualBorderTopWidth,
// box.ActualBorderRightWidth,
// box.ActualBorderBottomWidth
// );
//s_simpleRectBorderBuilder.BuildOverRefBounds(
// rect.Left,
// rect.Top,
// rect.Width,
// rect.Height,
// s_reusableBorderCoords);
switch (borderSide)
{
case CssSide.Top:
g.DrawLine((float)Math.Ceiling(rect.Left), rect.Top + box.ActualBorderTopWidth / 2, rect.Right - 1, rect.Top + box.ActualBorderTopWidth / 2);
break;
case CssSide.Left:
g.DrawLine(rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Ceiling(rect.Top), rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Floor(rect.Bottom));
break;
case CssSide.Bottom:
g.DrawLine((float)Math.Ceiling(rect.Left), rect.Bottom - box.ActualBorderBottomWidth / 2, rect.Right - 1, rect.Bottom - box.ActualBorderBottomWidth / 2);
break;
case CssSide.Right:
g.DrawLine(rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Ceiling(rect.Top), rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Floor(rect.Bottom));
break;
}
g.StrokeWidth = prevStrokeW;
g.StrokeColor = prevColor;
}
break;
}
}
}
public static void OffsetCanvasOriginX(this DrawBoard drawBoard, int dx)
{
//TODO: review offset function
drawBoard.OffsetCanvasOrigin(dx, 0);
}
internal void PaintRuns(PaintVisitor p)
{
List <CssRun> tmpRuns = _runs;
int j = tmpRuns.Count;
if (j < 1)
{
return;
}
//-----------------------
//iterate from each words
CssBox latestOwner = null;
DrawBoard innerCanvas = p.InnerDrawBoard;
RequestFont enterFont = innerCanvas.CurrentFont;
Color enterColor = innerCanvas.CurrentTextColor;
for (int i = 0; i < j; ++i)
{
//-----------------
#if DEBUG
dbugCounter.dbugRunPaintCount++;
#endif
//-----------------
CssRun w = tmpRuns[i];
switch (w.Kind)
{
case CssRunKind.SolidContent:
{
w.OwnerBox.Paint(p, new RectangleF(w.Left, w.Top, w.Width, w.Height));
}
break;
case CssRunKind.BlockRun:
{
//Console.WriteLine("blockrun");
CssBlockRun blockRun = (CssBlockRun)w;
int ox = p.CanvasOriginX;
int oy = p.CanvasOriginY;
//p.SetCanvasOrigin(ox + (int)(blockRun.Left + blockRun.ContentBox.LocalX), oy + (int)blockRun.Top);
p.SetCanvasOrigin(ox + (int)(blockRun.Left), oy + (int)blockRun.Top);
blockRun.ContentBox.Paint(p);
p.SetCanvasOrigin(ox, oy);
}
break;
case CssRunKind.Text:
{
if (latestOwner != w.OwnerBox)
{
//change
latestOwner = w.OwnerBox;
//change font when change owner
p.InnerDrawBoard.CurrentFont = latestOwner.ResolvedFont;
p.InnerDrawBoard.CurrentTextColor = latestOwner.ActualColor;
}
CssTextRun textRun = (CssTextRun)w;
p.DrawText(CssBox.UnsafeGetTextBuffer(w.OwnerBox),
textRun.TextStartIndex,
textRun.TextLength,
new PointF(w.Left, w.Top),
new SizeF(w.Width, w.Height));
}
break;
default:
{
#if DEBUG
// w.OwnerBox.dbugPaintTextWordArea(g, offset, w);
#endif
}
break;
}
}
innerCanvas.CurrentFont = enterFont;
innerCanvas.CurrentTextColor = enterColor;
}
internal void PaintDecoration(DrawBoard g, RectangleF rectangle, bool isFirst, bool isLast)
{
float y = 0f;
switch (this.TextDecoration)
{
default:
return;
case Css.CssTextDecoration.Underline:
{
//TODO: correct this ...
//var h = g.MeasureString(" ", ActualFont).Height;
//float desc = FontsUtils.GetDescentPx(ActualFont);
//y = (float)Math.Round(rectangle.Top + h - desc + 0.5);
RequestFont afont = ResolvedFont;
//PixelFarm.Drawing.Fonts.ActualFont ff = afont.ActualFont;
var h = afont.SizeInPixels;
float desc = (float)afont.DescentInPixels; // fontInfo.DescentPx;
y = (float)Math.Round(rectangle.Top + h - desc);
}
break;
case Css.CssTextDecoration.LineThrough:
{
y = rectangle.Top + rectangle.Height / 2f;
}
break;
case Css.CssTextDecoration.Overline:
{
y = rectangle.Top;
}
break;
}
//y -= ActualPaddingBottom - ActualBorderBottomWidth;
y -= (ActualPaddingBottom + ActualBorderBottomWidth);
float x1 = rectangle.X;
if (isFirst)
{
x1 += ActualPaddingLeft + ActualBorderLeftWidth;
}
float x2 = rectangle.Right;
if (isLast)
{
x2 -= ActualPaddingRight + ActualBorderRightWidth;
}
var prevColor = g.StrokeColor;
g.StrokeColor = ActualColor;
g.DrawLine(x1, y, x2, y);
g.StrokeColor = prevColor;
}
public void SetCanvas(DrawBoard canvas)
{
_openGLViewport.SetCanvas(canvas);
}
protected override void OnStartDemo(SampleViewport viewport)
{
PaintLab.Svg.SvgParser parser = new SvgParser();
_backBoard = new BackDrawBoardUI(400, 400);
_backBoard.BackColor = Color.White;
viewport.AddContent(_backBoard);
box1 = new LayoutFarm.CustomWidgets.SimpleBox(50, 50);
box1.BackColor = Color.Red;
box1.SetLocation(10, 10);
//box1.dbugTag = 1;
SetupActiveBoxProperties(box1);
_backBoard.AddChild(box1);
//----------------------
//load lion svg
string file = @"d:\\WImageTest\\lion.svg";
string svgContent = System.IO.File.ReadAllText(file);
WebLexer.TextSnapshot textSnapshot = new WebLexer.TextSnapshot(svgContent);
parser.ParseDocument(textSnapshot);
//
SvgRenderVx svgRenderVx = parser.GetResultAsRenderVx();
var uiSprite = new UISprite(10, 10);
uiSprite.LoadSvg(svgRenderVx);
_backBoard.AddChild(uiSprite);
//--------
rectBoxController.Init();
//------------
viewport.AddContent(rectBoxController);
//foreach (var ui in rectBoxController.GetControllerIter())
//{
// viewport.AddContent(ui);
//}
//--------
var evListener = new GeneralEventListener();
uiSprite.AttachExternalEventListener(evListener);
evListener.MouseDown += (e) =>
{
//e.MouseCursorStyle = MouseCursorStyle.Pointer;
////--------------------------------------------
//e.SetMouseCapture(rectBoxController.ControllerBoxMain);
rectBoxController.UpdateControllerBoxes(box1);
rectBoxController.Focus();
//System.Console.WriteLine("click :" + (count++));
};
rectBoxController.ControllerBoxMain.KeyDown += (s1, e1) =>
{
if (e1.Ctrl && e1.KeyCode == UIKeys.X)
{
//test copy back image buffer from current rect area
#if DEBUG
//test save some area
int w = rectBoxController.ControllerBoxMain.Width;
int h = rectBoxController.ControllerBoxMain.Height;
using (DrawBoard gdiDrawBoard = DrawBoardCreator.CreateNewDrawBoard(1, w, h))
{
gdiDrawBoard.OffsetCanvasOrigin(rectBoxController.ControllerBoxMain.Left, rectBoxController.ControllerBoxMain.Top);
_backBoard.CurrentPrimaryRenderElement.CustomDrawToThisCanvas(gdiDrawBoard, new Rectangle(0, 0, w, h));
var img2 = new ActualImage(w, h);
//copy content from drawboard to target image and save
gdiDrawBoard.RenderTo(img2, 0, 0, w, h);
img2.dbugSaveToPngFile("d:\\WImageTest\\ddd001.png");
}
#endif
}
};
}
public override void DrawChildContent(DrawBoard canvas, Rectangle updateArea)
{
//TODO: temp fixed, review here again,
GridCell leftTopGridItem = this.GetCell(0, 0);
if (leftTopGridItem == null)
{
return;
}
GridCell rightBottomGridItem = this.GetCell(this.RowCount - 1, this.ColumnCount - 1);
if (rightBottomGridItem == null)
{
return;
}
this.BeginDrawingChildContent();
GridColumn startColumn = leftTopGridItem.column;
GridColumn currentColumn = startColumn;
GridRow startRow = leftTopGridItem.row;
GridColumn stopColumn = rightBottomGridItem.column.NextColumn;
GridRow stopRow = rightBottomGridItem.row.NextRow;
int startRowId = startRow.RowIndex;
int stopRowId = 0;
if (stopRow == null)
{
stopRowId = gridRows.Count;
}
else
{
stopRowId = stopRow.RowIndex;
}
int n = 0;
var prevColor = canvas.StrokeColor;
canvas.StrokeColor = _gridBorderColor;
do
{
GridCell startGridItemInColumn = currentColumn.GetCell(startRowId);
GridCell stopGridItemInColumn = currentColumn.GetCell(stopRowId - 1);
//draw vertical line
canvas.DrawLine(
startGridItemInColumn.Right,
startGridItemInColumn.Y,
stopGridItemInColumn.Right,
stopGridItemInColumn.Bottom);
if (n == 0)
{
//draw horizontal line
int horizontalLineWidth = rightBottomGridItem.Right - startGridItemInColumn.X;
for (int i = startRowId; i < stopRowId; i++)
{
GridCell gridItem = currentColumn.GetCell(i);
int x = gridItem.X;
int gBottom = gridItem.Bottom;
canvas.DrawLine(
x, gBottom,
x + horizontalLineWidth, gBottom);
}
n = 1;
}
currentColumn = currentColumn.NextColumn;
} while (currentColumn != stopColumn);
canvas.StrokeColor = prevColor;
currentColumn = startColumn;
//----------------------------------------------------------------------------
Rectangle uArea = updateArea;
do
{
for (int i = startRowId; i < stopRowId; i++)
{
GridCell gridItem = currentColumn.GetCell(i);
if (gridItem != null && gridItem.HasContent)
{
int x = gridItem.X;
int y = gridItem.Y;
canvas.OffsetCanvasOrigin(x, y);
updateArea = uArea;//reset
updateArea.Offset(-x, -y);
var renderContent = gridItem.ContentElement as RenderElement;
if (renderContent != null)
{
if (canvas.PushClipAreaRect(gridItem.Width, gridItem.Height, ref updateArea))
{
renderContent.DrawToThisCanvas(canvas, updateArea);
}
canvas.PopClipAreaRect();
}
canvas.OffsetCanvasOrigin(-x, -y);
updateArea.Offset(x, y);
}
#if DEBUG
else
{
//canvas.DrawText(new char[] { '.' }, gridItem.X, gridItem.Y);
}
#endif
}
currentColumn = currentColumn.NextColumn;
} while (currentColumn != stopColumn);
this.FinishDrawingChildContent();
}
public void UnBind()
{
_drawBoard = null;
_htmlVisualRoot = null;
}
public void Bind(HtmlVisualRoot htmlVisualRoot, DrawBoard drawBoard)
{
_htmlVisualRoot = htmlVisualRoot;
_drawBoard = drawBoard;
}
internal static PaintVisitor GetSharedPaintVisitor(HtmlVisualRoot htmlVisualRoot, DrawBoard canvas)
{
PaintVisitor painter = null;
if (s_paintVisitorStock.Count == 0)
{
painter = new PaintVisitor();
}
else
{
painter = s_paintVisitorStock.Dequeue();
}
painter.Bind(htmlVisualRoot, canvas);
return(painter);
}
public static void DrawBorder(CssSide border, PointF[] borderPts, DrawBoard g, CssBox box, Color solidColor, RectangleF rectangle)
{
SetInOutsetRectanglePoints(border, box, rectangle, true, true, borderPts);
g.FillPolygon(solidColor, borderPts);
}
protected override void RenderClientContent(DrawBoard d, UpdateArea updateArea)
{
//TODO: review here,
if (_myHtmlVisualRoot == null)
{
return;
}
bool useBackbuffer = d.IsGpuDrawBoard;
//useBackbuffer = false;
//... TODO: review here, check doc update here?
_myHtmlVisualRoot.CheckDocUpdate();
if (useBackbuffer)
{
PaintVisitor painter = PaintVisitorStock.GetSharedPaintVisitor(_myHtmlVisualRoot, d);
if (_builtInBackBuffer == null)
{
_builtInBackBuffer = painter.CreateOffscreenDrawBoard(this.Width, this.Height);
}
#if DEBUG
painter.dbugDrawDiagonalBox(Color.Blue, this.X, this.Y, this.Width, this.Height);
#endif
if (!_builtInBackBuffer.IsValid)
{
//painter.FillRectangle(Color.Red, 0, 0, 100, 100);//debug
//painter.DrawText(i.ToString().ToCharArray(), 0, 1, new PointF(0, 0), new SizeF(100, 100)); //debug
float backupViewportW = painter.ViewportWidth; //backup
float backupViewportH = painter.ViewportHeight; //backup
painter.EnterNewDrawboardBuffer(_builtInBackBuffer); //*** switch to builtInBackbuffer
painter.SetViewportSize(this.Width, this.Height);
if (!_hasAccumRect)
{
_invalidateRect = new Rectangle(0, 0, Width, Height);
}
#if DEBUG
//System.Diagnostics.Debug.WriteLine("inv_rect:" + _invalidateRect + "," + painter.ToString());
#endif
if (painter.PushLocalClipArea(
_invalidateRect.Left, _invalidateRect.Top,
_invalidateRect.Width, _invalidateRect.Height))
{
#if DEBUG
//for debug , test clear with random color
//another useful technique to see latest clear area frame-by-frame => use random color
//painter.Clear(ColorEx.dbugGetRandomColor());
painter.Clear(Color.White);
#else
painter.Clear(Color.White);
#endif
_myHtmlVisualRoot.PerformPaint(painter);
painter.PopLocalClipArea();
}
//
_builtInBackBuffer.IsValid = true;
_hasAccumRect = false;
painter.ExitCurrentDrawboardBuffer(); //*** switch back
painter.SetViewportSize(backupViewportW, backupViewportH); //restore viewport size
}
painter.DrawImage(_builtInBackBuffer.GetImage(), 0, 0, this.Width, this.Height);
PaintVisitorStock.ReleaseSharedPaintVisitor(painter);
}
#if DEBUG
else if (dbugPreferSoftwareRenderer && d.IsGpuDrawBoard)
{
//TODO: review this again ***
//test built-in 'shared' software rendering surface
DrawBoard cpuDrawBoard = null;
if ((cpuDrawBoard = d.GetCpuBlitDrawBoard()) != null)
{
cpuDrawBoard.Clear(Color.White);
PaintVisitor painter = PaintVisitorStock.GetSharedPaintVisitor(_myHtmlVisualRoot, cpuDrawBoard);
painter.SetViewportSize(this.Width, this.Height);
#if DEBUG
painter.dbugDrawDiagonalBox(Color.Blue, this.X, this.Y, this.Width, this.Height);
#endif
_myHtmlVisualRoot.PerformPaint(painter);
PaintVisitorStock.ReleaseSharedPaintVisitor(painter);
//then copy from cpu to gpu
d.BlitFrom(cpuDrawBoard, X, Y, this.Width, this.Height, 0, 0);
}
}
#endif
else
{
PaintVisitor painter = PaintVisitorStock.GetSharedPaintVisitor(_myHtmlVisualRoot, d);
painter.SetViewportSize(this.Width, this.Height);
#if DEBUG
//System.Diagnostics.Debug.WriteLine(">> 500x500");
painter.dbugDrawDiagonalBox(Color.Blue, this.X, this.Y, this.Width, this.Height);
//for debug , test clear with random color
//another useful technique to see latest clear area frame-by-frame => use random color
//painter.Clear(Color.FromArgb(255, dbugRandom.Next(0, 255), dbugRandom.Next(0, 255), dbugRandom.Next(0, 255)));
#endif
#if DEBUG
//System.Diagnostics.Debug.WriteLine("inv_rect:" + _invalidateRect + "," + painter.ToString());
#endif
//painter.SetClipRect(new Rectangle(0, 0, 200, 200));
_myHtmlVisualRoot.PerformPaint(painter);
#if DEBUG
//System.Diagnostics.Debug.WriteLine("<< 500x500");
//painter.dbugDrawDiagonalBox(Color.Blue, this.X, this.Y, this.Width, this.Height);
#endif
PaintVisitorStock.ReleaseSharedPaintVisitor(painter);
}
}
public MicroPainter(DrawBoard drawBoard)
{
_viewportWidth = 0;
_viewportHeight = 0;
_drawBoard = drawBoard;
}
/// <summary>
/// Paints the background of the box
/// </summary>
/// <param name="g">the device to draw into</param>
/// <param name="rect">the bounding rectangle to draw in</param>
/// <param name="isFirst">is it the first rectangle of the element</param>
/// <param name="isLast">is it the last rectangle of the element</param>
internal void PaintBackground(PaintVisitor p, RectangleF rect, bool isFirst, bool isLast)
{
//return;
//if (this.dbugMark1 > 0)
//{
// Console.WriteLine(this.dbugMark1);
// if ((this.dbugMark1 % 2) == 0)
// {
// }
// else
// {
// }
//}
if (!this.HasVisibleBgColor)
{
return;
}
if (rect.Width > 0 && rect.Height > 0)
{
Brush brush = null;
bool dispose = false;
if (BackgroundGradient != Color.Transparent)
{
//use bg gradient
brush = LinearGradientBrush.CreateLinearGradientBrush(rect,
ActualBackgroundColor,
ActualBackgroundGradient,
ActualBackgroundGradientAngle);
dispose = true;
}
else if (RenderUtils.IsColorVisible(ActualBackgroundColor))
{
brush = new SolidBrush(this.ActualBackgroundColor);
dispose = true;
}
DrawBoard g = p.InnerCanvas;
SmoothingMode smooth = g.SmoothingMode;
if (brush != null)
{
// atodo: handle it correctly (tables background)
// if (isLast)
// rectangle.Width -= ActualWordSpacing + CssUtils.GetWordEndWhitespace(ActualFont);
GraphicsPath roundrect = null;
bool hasSomeRoundCorner = this.HasSomeRoundCorner;
if (hasSomeRoundCorner)
{
roundrect = RenderUtils.GetRoundRect(rect, ActualCornerNW, ActualCornerNE, ActualCornerSE, ActualCornerSW);
}
if (!p.AvoidGeometryAntialias && hasSomeRoundCorner)
{
g.SmoothingMode = SmoothingMode.AntiAlias;
}
if (roundrect != null)
{
g.FillPath(brush, roundrect);
}
else
{
g.FillRectangle(brush, (float)Math.Ceiling(rect.X), (float)Math.Ceiling(rect.Y), rect.Width, rect.Height);
}
g.SmoothingMode = smooth;
if (roundrect != null)
{
roundrect.Dispose();
}
if (dispose)
{
brush.Dispose();
}
}
if (isFirst)
{
var bgImageBinder = this.BackgroundImageBinder;
if (bgImageBinder != null && bgImageBinder.Image != null)
{
BackgroundImagePaintHelper.DrawBackgroundImage(g, this, bgImageBinder, rect);
}
}
}
}
//============================================================== //render... public abstract void CustomDrawToThisCanvas(DrawBoard canvas, Rectangle updateArea);
/// <summary>
/// Draw specific border (top/bottom/left/right) with the box data (style/width/rounded).<br/>
/// </summary>
/// <param name="borderSide">desired border to draw</param>
/// <param name="box">the box to draw its borders, contain the borders data</param>
/// <param name="g">the device to draw into</param>
/// <param name="rect">the rectangle the border is enclosing</param>
/// <param name="isLineStart">Specifies if the border is for a starting line (no bevel on left)</param>
/// <param name="isLineEnd">Specifies if the border is for an ending line (no bevel on right)</param>
static void DrawBorder(CssSide borderSide, CssBox box,
PaintVisitor p, RectangleF rect, bool isLineStart, bool isLineEnd)
{
float actualBorderWidth;
Color borderColor;
CssBorderStyle style;
GetBorderBorderDrawingInfo(box, borderSide, out style, out borderColor, out actualBorderWidth);
DrawBoard g = p.InnerDrawBoard;
if (box.HasSomeRoundCorner)
{
GraphicsPath borderPath = GetRoundedBorderPath(p, borderSide, box, rect);
if (borderPath != null)
{
// rounded border need special path
var smooth = g.SmoothingMode;
if (!p.AvoidGeometryAntialias && box.HasSomeRoundCorner)
{
g.SmoothingMode = SmoothingMode.AntiAlias;
}
p.DrawPath(borderPath, borderColor, actualBorderWidth);
//using (var pen = GetPen(p.Platform, style, borderColor, actualBorderWidth))
//using (borderPath)
//{
// g.DrawPath(pen, borderPath);
//}
g.SmoothingMode = smooth;
}
}
else
{
// non rounded border
switch (style)
{
case CssBorderStyle.Inset:
case CssBorderStyle.Outset:
{
// inset/outset border needs special rectangle
PointF[] borderPnts = new PointF[4];
SetInOutsetRectanglePoints(borderSide, box, rect, isLineStart, isLineEnd, borderPnts);
g.FillPolygon(borderColor, borderPnts);
}
break;
default:
{
// solid/dotted/dashed border draw as simple line
//using (var pen = GetPen(p.Platform, style, borderColor, actualBorderWidth))
//{
var prevColor = g.StrokeColor;
g.StrokeColor = borderColor;
float prevStrokeW = g.StrokeWidth;
g.StrokeWidth = actualBorderWidth;
//s_simpleRectBorderBuilder.SetBorderWidth(
// box.ActualBorderLeftWidth,
// box.ActualBorderTopWidth,
// box.ActualBorderRightWidth,
// box.ActualBorderBottomWidth
// );
//s_simpleRectBorderBuilder.BuildOverRefBounds(
// rect.Left,
// rect.Top,
// rect.Width,
// rect.Height,
// s_reusableBorderCoords);
switch (borderSide)
{
case CssSide.Top:
g.DrawLine((float)Math.Ceiling(rect.Left), rect.Top + box.ActualBorderTopWidth / 2, rect.Right - 1, rect.Top + box.ActualBorderTopWidth / 2);
break;
case CssSide.Left:
g.DrawLine(rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Ceiling(rect.Top), rect.Left + box.ActualBorderLeftWidth / 2, (float)Math.Floor(rect.Bottom));
break;
case CssSide.Bottom:
g.DrawLine((float)Math.Ceiling(rect.Left), rect.Bottom - box.ActualBorderBottomWidth / 2, rect.Right - 1, rect.Bottom - box.ActualBorderBottomWidth / 2);
break;
case CssSide.Right:
g.DrawLine(rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Ceiling(rect.Top), rect.Right - box.ActualBorderRightWidth / 2, (float)Math.Floor(rect.Bottom));
break;
}
g.StrokeWidth = prevStrokeW;
g.StrokeColor = prevColor;
}
break;
}
}
}
public VisualPaintEventArgs(DrawBoard canvas, Rectangle updateArea)
{
Canvas = canvas;
UpdateArea = updateArea;
}
public static void OffsetCanvasOrigin(this DrawBoard drawBoard, int dx, int dy)
{
//TODO: review offset function
drawBoard.SetCanvasOrigin(drawBoard.OriginX + dx, drawBoard.OriginY + dy);
}
//
public override void CustomDrawToThisCanvas(DrawBoard canvas, Rectangle updateArea)
{
int bWidth = this.Width;
int bHeight = this.Height;
#if DEBUG
//canvas.dbug_DrawCrossRect(Color.Red, new Rectangle(0, 0, bWidth, bHeight));
//canvas.DrawRectangle(Color.Red, 0, 0, bWidth, bHeight);
#endif
if (!this.HasStyle)
{
canvas.DrawText(_mybuffer, new Rectangle(0, 0, bWidth, bHeight), 0);
}
else
{
TextSpanStyle style = this.SpanStyle;
switch (EvaluateFontAndTextColor(canvas, style))
{
case DIFF_FONT_SAME_TEXT_COLOR:
{
canvas.DrawText(_mybuffer,
new Rectangle(0, 0, bWidth, bHeight),
style.ContentHAlign);
}
break;
case DIFF_FONT_DIFF_TEXT_COLOR:
{
RequestFont prevFont = canvas.CurrentFont;
Color prevColor = canvas.CurrentTextColor;
canvas.CurrentFont = style.ReqFont;
canvas.CurrentTextColor = style.FontColor;
canvas.DrawText(_mybuffer,
new Rectangle(0, 0, bWidth, bHeight),
style.ContentHAlign);
canvas.CurrentFont = prevFont;
canvas.CurrentTextColor = prevColor;
}
break;
case SAME_FONT_DIFF_TEXT_COLOR:
{
Color prevColor = canvas.CurrentTextColor;
canvas.CurrentTextColor = style.FontColor;
canvas.DrawText(_mybuffer,
new Rectangle(0, 0, bWidth, bHeight),
style.ContentHAlign);
canvas.CurrentTextColor = prevColor;
}
break;
default:
{
canvas.DrawText(_mybuffer,
new Rectangle(0, 0, bWidth, bHeight),
style.ContentHAlign);
}
break;
}
}
}
public static void OffsetCanvasOriginY(this DrawBoard drawBoard, int dy)
{
//TODO: review offset function
drawBoard.OffsetCanvasOrigin(0, dy);
}
public abstract void BlitFrom(DrawBoard src, float srcX, float srcY, float srcW, float srcH, float dstX, float dstY);
