public sealed override void CustomDrawToThisCanvas(Canvas canvas, Rectangle updateArea)
{
canvas.OffsetCanvasOrigin(-myviewportX, -myviewportY);
updateArea.Offset(myviewportX, myviewportY);
this.DrawBoxContent(canvas, updateArea);
canvas.OffsetCanvasOrigin(myviewportX, myviewportY);
updateArea.Offset(-myviewportX, -myviewportY);
}
public virtual void InvalidateGraphics(Rectangle clientArea)
{
//bubble up to parent
//clientArea => area relative to this element
//adjust to
//adjust client area
var parentBox = this.ParentBox;
if (parentBox != null)
{
clientArea.Offset((int)this.LocalX, (int)this.LocalY);
parentBox.InvalidateGraphics(clientArea);
}
}
public void InvalidateGraphicArea(RenderElement fromElement, ref Rectangle elemClientRect)
{
//total bounds = total bounds at level
if (this.IsInRenderPhase) { return; }
//--------------------------------------
//bubble up ,find global rect coord
//and then merge to accumulate rect
//int globalX = 0;
//int globalY = 0;
Point globalPoint = new Point();
bool isBubbleUp = false;
#if DEBUG
int dbug_ncount = 0;
dbugWriteStopGfxBubbleUp(fromElement, ref dbug_ncount, dbug_ncount, ">> :" + elemClientRect.ToString());
#endif
do
{
if (!fromElement.Visible)
{
#if DEBUG
dbugWriteStopGfxBubbleUp(fromElement, ref dbug_ncount, 0, "EARLY-RET: ");
#endif
return;
}
else if (fromElement.BlockGraphicUpdateBubble)
{
#if DEBUG
dbugWriteStopGfxBubbleUp(fromElement, ref dbug_ncount, 0, "BLOCKED2: ");
#endif
return;
}
//---------------------------------------------------------------------
#if DEBUG
dbugWriteStopGfxBubbleUp(fromElement, ref dbug_ncount, dbug_ncount, ">> ");
#endif
globalPoint.Offset(fromElement.X, fromElement.Y);
//globalX += fromElement.BubbleUpX;
//globalY += fromElement.BubbleUpY;
if (fromElement.MayHasViewport && isBubbleUp)
{
//elemClientRect.Offset(globalX, globalY);
elemClientRect.Offset(globalPoint);
if (fromElement.HasDoubleScrollableSurface)
{
//container.VisualScrollableSurface.WindowRootNotifyInvalidArea(elementClientRect);
}
Rectangle elementRect = fromElement.RectBounds;
elementRect.Offset(fromElement.ViewportX, fromElement.ViewportY);
elemClientRect.Intersect(elementRect);
globalPoint.X = -fromElement.ViewportX;
globalPoint.Y = -fromElement.ViewportY;
//globalX = -fromElement.ViewportX;
//globalY = -fromElement.ViewportY;
}
if (fromElement.IsTopWindow)
{
break;
}
else
{
#if DEBUG
if (fromElement.dbugParentVisualElement == null)
{
dbugWriteStopGfxBubbleUp(fromElement, ref dbug_ncount, 0, "BLOCKED3: ");
}
#endif
var parentLink = fromElement.MyParentLink;
if (parentLink == null)
{
return;
}
parentLink.AdjustLocation(ref globalPoint);
//move up
fromElement = parentLink.ParentRenderElement;// fromElement.ParentRenderElement;
if (fromElement == null)
{
return;
}
}
isBubbleUp = true;
} while (true);
#if DEBUG
var dbugMyroot = this;
if (dbugMyroot.dbugEnableGraphicInvalidateTrace
&& dbugMyroot.dbugGraphicInvalidateTracer != null)
{
while (dbug_ncount > 0)
{
dbugMyroot.dbugGraphicInvalidateTracer.PopElement();
dbug_ncount--;
}
}
#endif
//----------------------------------------
//elemClientRect.Offset(globalX, globalY);
elemClientRect.Offset(globalPoint);
if (elemClientRect.Top > this.Height
|| elemClientRect.Left > this.Width
|| elemClientRect.Bottom < 0
|| elemClientRect.Right < 0)
{
//no intersect with
#if DEBUG
if (dbugMyroot.dbugEnableGraphicInvalidateTrace &&
dbugMyroot.dbugGraphicInvalidateTracer != null)
{
dbugMyroot.dbugGraphicInvalidateTracer.WriteInfo("ZERO-EEX");
dbugMyroot.dbugGraphicInvalidateTracer.WriteInfo("\r\n");
}
#endif
return;
}
//--------------------------------------------------------------------------------------------------
if (!hasAccumRect)
{
accumulateInvalidRect = elemClientRect;
hasAccumRect = true;
}
else
{
accumulateInvalidRect = Rectangle.Union(accumulateInvalidRect, elemClientRect);
}
#if DEBUG
if (dbugMyroot.dbugEnableGraphicInvalidateTrace &&
dbugMyroot.dbugGraphicInvalidateTracer != null)
{
string state_str = "ACC: ";
if (this.dbugNeedContentArrangement || this.dbugNeedReCalculateContentSize)
{
state_str = "!!" + state_str;
}
dbugMyroot.dbugGraphicInvalidateTracer.WriteInfo("ACC: " + accumulateInvalidRect.ToString());
dbugMyroot.dbugGraphicInvalidateTracer.WriteInfo("\r\n");
}
#endif
}
public override void DrawChildContent(Canvas canvasPage, Rectangle updateArea)
{
if ((layerFlags & IS_LAYER_HIDDEN) != 0)
{
return;
}
this.BeginDrawingChildContent();
foreach (RenderElement child in this.GetDrawingIter())
{
if (child.IntersectsWith(ref updateArea))
{
int x = child.X;
int y = child.Y;
canvasPage.OffsetCanvasOrigin(x, y);
updateArea.Offset(-x, -y);
child.DrawToThisCanvas(canvasPage, updateArea);
canvasPage.OffsetCanvasOrigin(-x, -y);
updateArea.Offset(x, y);
}
}
this.FinishDrawingChildContent();
}
public override void Paint(PaintVisitor p, RectangleF r)
{
var updateArea = new Rectangle((int)r.Left, (int)r.Top, (int)r.Width, (int)r.Height);
int x = (int)updateArea.Left;
int y = (int)updateArea.Top;
var canvasPage = p.InnerCanvas;
canvasPage.OffsetCanvasOrigin(x, y);
updateArea.Offset(-x, -y);
externalRun.RenderElement.DrawToThisCanvas(canvasPage, updateArea);
canvasPage.OffsetCanvasOrigin(-x, -y);
}
public override void DrawChildContent(Canvas canvas, Rectangle updateArea)
{
//GridCell leftTopGridItem = GetGridItemByPosition(updateArea.Left, updateArea.Top);
//if (leftTopGridItem == null)
//{
// return;
//}
//GridCell rightBottomGridItem = GetGridItemByPosition(updateArea.Right, updateArea.Bottom);
//if (rightBottomGridItem == null)
//{
// return;
//}
//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 = Color.Gray;
//canvas.DrawLine(0, 0, 100, 100);
//canvas.DrawLine(0, 100, 100, 0);
//if (startRowId > 0)
//{
// Console.WriteLine(startRowId);
//}
//canvas.DrawRectangle(Color.Red, updateArea.Left, updateArea.Top, updateArea.Width, updateArea.Height);
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;
//----------------------------------------------------------------------------
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.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();
}
