public void PaintParaBox()
{
AssembledStyles styles = new AssembledStyles();
var clientRuns = new List<IClientRun>();
BlockBox box0 = new BlockBox(styles, Color.Red, 72000, 36000);
clientRuns.Add(box0);
BlockBox box1 = new BlockBox(styles, Color.Blue, 36000, 18000);
clientRuns.Add(box1);
BlockBox box2 = new BlockBox(styles, Color.Red, 24000, 18000);
clientRuns.Add(box2);
BlockBox box3 = new BlockBox(styles, Color.Red, 72000, 36000);
clientRuns.Add(box3);
BlockBox box4 = new BlockBox(styles, Color.Red, 36000, 36000);
clientRuns.Add(box4);
TextSource source = new TextSource(clientRuns, null);
ParaBox para = new ParaBox(styles, source);
RootBox root = new RootBox(styles);
root.AddBox(para);
MockGraphics graphics = new MockGraphics();
LayoutInfo layoutArgs = ParaBuilderTests.MakeLayoutInfo(100, graphics);
root.Layout(layoutArgs);
PaintTransform ptrans = new PaintTransform(2, 2, 96, 96, 0, 0, 96, 96);
root.Paint(graphics, ptrans);
Assert.AreEqual(5, graphics.RectanglesDrawn.Count);
VerifyRect(2, 2, 96, 48, graphics, 0, Color.Red);
VerifyRect(2, 48+2, 48, 24, graphics, 1, Color.Blue);
VerifyRect(2+48, 48 + 2, 32, 24, graphics, 2, Color.Red);
VerifyRect(2, 24 + 48 + 2, 96, 48, graphics, 3, Color.Red);
VerifyRect(2, 48 + 24 + 48 + 2, 48, 48, graphics, 4, Color.Red);
}
private void VerifyPaint(RootBox root, Rectangle clipRect, int xScrollOffset, int yScrollOffset, Rectangle[] paintRects)
{
MockGraphics graphics = new MockGraphics();
graphics.ClipRectangle = clipRect;
PaintTransform ptrans = new PaintTransform(0, 0, 96, 96, xScrollOffset, yScrollOffset, 96, 96);
root.Paint(graphics, ptrans);
var drawActions = graphics.DrawActions; // after the paint, it gets created when first rect added.
if (paintRects == null || paintRects.Length == 0)
{
Assert.IsTrue(drawActions == null || drawActions.Count == 0);
return;
}
Assert.That(drawActions, Has.Count.EqualTo(paintRects.Length * 2));
int position = 0;
// First all the blocks get drawn in their PaintBackground routine
foreach (var rect in paintRects)
{
VerifyRect(drawActions, ref position, rect);
}
// Then we verify that the PaintForeground routines got called.
for (; position < drawActions.Count; position++)
{
Assert.That(drawActions[position], Is.InstanceOf(typeof(FgBlockBox)));
}
}
public void PaintBarBox()
{
AssembledStyles styles = new AssembledStyles();
BlockBox box = new BlockBox(styles, Color.Red, 72000, 36000);
RootBox root = new RootBox(styles);
root.AddBox(box);
LayoutInfo transform = MakeLayoutInfo();
root.Layout(transform);
PaintTransform ptrans = new PaintTransform(2, 2, 96, 96, 0, 0, 96, 96);
MockGraphics graphics = new MockGraphics();
root.Paint(graphics, ptrans);
Assert.AreEqual(1, graphics.RectanglesDrawn.Count);
Assert.AreEqual(new Rectangle(2, 2, 96, 48), graphics.RectanglesDrawn[0]);
Assert.AreEqual((int)ColorUtil.ConvertColorToBGR(Color.Red), graphics.BackColor);
}
public void PaintPictureBox()
{
AssembledStyles styles = new AssembledStyles();
Bitmap bm = new Bitmap(20, 30);
ImageBox box = new ImageBox(styles.WithMargins(new Thickness(72.0 / 96.0 * 2.0))
.WithBorders(new Thickness(72.0 / 96.0 * 3.0))
.WithPads(new Thickness(72.0 / 96.0 * 7.0, 72.0 / 96.0 * 8.0, 72.0 / 96.0 * 11.0, 72.0 / 96.0 * 13.0)), bm);
RootBox root = new RootBox(styles);
BlockBox block = new BlockBox(styles, Color.Yellow, 2000, 4000);
root.AddBox(block);
root.AddBox(box);
LayoutInfo transform = MakeLayoutInfo();
root.Layout(transform);
Assert.That(box.Height, Is.EqualTo(30 + 2 * 2 + 3 * 2 + 8 + 13));
Assert.That(box.Width, Is.EqualTo(20 + 2 * 2 + 3 * 2 + 7 + 11));
Assert.That(box.Ascent, Is.EqualTo(box.Height));
PaintTransform ptrans = new PaintTransform(2, 4, 96, 96, 10, 40, 96, 96);
MockGraphics graphics = new MockGraphics();
root.Paint(graphics, ptrans);
Assert.That(graphics.LastRenderPictureArgs, Is.Not.Null);
Assert.That(graphics.LastRenderPictureArgs.Picture, Is.EqualTo(box.Picture));
Assert.That(graphics.LastRenderPictureArgs.X, Is.EqualTo(2 - 10 + 2 + 3 + 7));
Assert.That(graphics.LastRenderPictureArgs.Y, Is.EqualTo(4 - 40 + block.Height + 2 + 3 + 8));
Assert.That(graphics.LastRenderPictureArgs.Cx, Is.EqualTo(20));
Assert.That(graphics.LastRenderPictureArgs.Cy, Is.EqualTo(30));
int hmWidth = box.Picture.Width;
int hmHeight = box.Picture.Height;
Assert.That(graphics.LastRenderPictureArgs.XSrc, Is.EqualTo(0));
Assert.That(graphics.LastRenderPictureArgs.YSrc, Is.EqualTo(hmHeight));
Assert.That(graphics.LastRenderPictureArgs.CxSrc, Is.EqualTo(hmWidth));
Assert.That(graphics.LastRenderPictureArgs.CySrc, Is.EqualTo(-hmHeight));
Assert.That(graphics.LastRenderPictureArgs.RcWBounds.left, Is.EqualTo(2 - 10 + 2 + 3 + 7));
Assert.That(graphics.LastRenderPictureArgs.RcWBounds.top, Is.EqualTo(4 - 40 + block.Height + 2 + 3 + 8));
Assert.That(graphics.LastRenderPictureArgs.RcWBounds.right, Is.EqualTo(2 - 10 + 2 + 3 + 7 + 20));
Assert.That(graphics.LastRenderPictureArgs.RcWBounds.bottom, Is.EqualTo(4 - 40 + block.Height + 2 + 3 + 8 + 30));
}
public void PaintBarBox()
{
AssembledStyles styles = new AssembledStyles();
BlockBox box = new BlockBox(styles, Color.Red, 72000, 36000);
RootBox root = new RootBox(styles);
root.AddBox(box);
LayoutInfo transform = MakeLayoutInfo();
root.Layout(transform);
PaintTransform ptrans = new PaintTransform(2, 2, 96, 96, 0, 0, 96, 96);
MockGraphics graphics = new MockGraphics();
root.Paint(graphics, ptrans);
Assert.AreEqual(1, graphics.RectanglesDrawn.Count);
Assert.AreEqual(new Rectangle(2, 2, 96, 48), graphics.RectanglesDrawn[0]);
Assert.AreEqual((int)ColorUtil.ConvertColorToBGR(Color.Red), graphics.BackColor);
}
public void PaintParaBox()
{
AssembledStyles styles = new AssembledStyles();
var clientRuns = new List <IClientRun>();
BlockBox box0 = new BlockBox(styles, Color.Red, 72000, 36000);
clientRuns.Add(box0);
BlockBox box1 = new BlockBox(styles, Color.Blue, 36000, 18000);
clientRuns.Add(box1);
BlockBox box2 = new BlockBox(styles, Color.Red, 24000, 18000);
clientRuns.Add(box2);
BlockBox box3 = new BlockBox(styles, Color.Red, 72000, 36000);
clientRuns.Add(box3);
BlockBox box4 = new BlockBox(styles, Color.Red, 36000, 36000);
clientRuns.Add(box4);
TextSource source = new TextSource(clientRuns, null);
ParaBox para = new ParaBox(styles, source);
RootBox root = new RootBox(styles);
root.AddBox(para);
MockGraphics graphics = new MockGraphics();
LayoutInfo layoutArgs = ParaBuilderTests.MakeLayoutInfo(100, graphics);
root.Layout(layoutArgs);
PaintTransform ptrans = new PaintTransform(2, 2, 96, 96, 0, 0, 96, 96);
root.Paint(graphics, ptrans);
Assert.AreEqual(5, graphics.RectanglesDrawn.Count);
VerifyRect(2, 2, 96, 48, graphics, 0, Color.Red);
VerifyRect(2, 48 + 2, 48, 24, graphics, 1, Color.Blue);
VerifyRect(2 + 48, 48 + 2, 32, 24, graphics, 2, Color.Red);
VerifyRect(2, 24 + 48 + 2, 96, 48, graphics, 3, Color.Red);
VerifyRect(2, 48 + 24 + 48 + 2, 48, 48, graphics, 4, Color.Red);
}
public void BackgroundAndUnderlinePainting()
{
var styles = new AssembledStyles();
RootBox root = new RootBoxFdo(styles);
SetupFakeRootSite(root);
var layoutInfo = HookupTests.MakeLayoutInfo(int.MaxValue / 2, m_gm.VwGraphics, 55);
root.RendererFactory = layoutInfo.RendererFactory;
root.Builder.Show(
Paragraph.Containing(
Display.Of("plain"),
Display.Of("underOnYellow").Underline(FwUnderlineType.kuntSingle).BackColor(Color.Yellow)
),
Paragraph.Containing(
Display.Of("doubleRedOnPink").Underline(FwUnderlineType.kuntDouble, Color.Red).BackColor(Color.Pink),
Display.Of("dotted").Underline(FwUnderlineType.kuntDotted),
Display.Of("dottedOnYellow").Underline(FwUnderlineType.kuntDotted).BackColor(Color.Yellow)
),
Paragraph.Containing(
Display.Of("dashed").Underline(FwUnderlineType.kuntDashed),
Display.Of("dashedRed").Underline(FwUnderlineType.kuntDashed).ForeColor(Color.Red),
Display.Of("squiggle").Underline(FwUnderlineType.kuntSquiggle)
)
);
root.Layout(layoutInfo);
var para1 = (ParaBox)root.FirstBox;
var stringBox1 = (StringBox)para1.FirstBox;
var seg1 = (FakeSegment)stringBox1.Segment;
// A convenient place to test that literals get Chrp with default user ws.
LgCharRenderProps chrp;
int ichMin, ichLim;
para1.Source.GetCharProps(0, out chrp, out ichMin, out ichLim);
Assert.That(chrp.ws, Is.EqualTo(layoutInfo.RendererFactory.UserWs));
// This segment has just one chunk of underline, the second run.
seg1.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{
Lefts = new[] { 10 }, Rights = new[] { 20 }, Tops = new[] { 15 }
});
// Todo: add expectations for each run of underlining.
var para2 = (ParaBox)para1.Next;
var stringBox2 = (StringBox)para2.FirstBox;
var seg2 = (FakeSegment)stringBox2.Segment;
// For the double red underline, we'll pretend there are two line segments.
seg2.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{
Lefts = new[] { 5, 15 }, Rights = new[] { 10, 20 }, Tops = new[] { 15, 16 }
});
seg2.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{
Lefts = new[] { 12 }, Rights = new[] { 22 }, Tops = new[] { 13 }
});
seg2.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{
Lefts = new[] { 30 }, Rights = new[] { 41 }, Tops = new[] { 12 }
});
var para3 = (ParaBox)para2.Next;
var stringBox3 = (StringBox)para3.FirstBox;
var seg3 = (FakeSegment)stringBox3.Segment;
seg3.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{
Lefts = new[] { 0 }, Rights = new[] { 10 }, Tops = new[] { 11 }
});
seg3.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{
Lefts = new[] { 10 }, Rights = new[] { 20 }, Tops = new[] { 11 }
});
seg3.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{
Lefts = new[] { 30 }, Rights = new[] { 40 }, Tops = new[] { 11 }
});
// We want to keep track of the sequence of paint operations in all three segments.
var drawActions = new List <object>();
seg1.DrawActions = seg2.DrawActions = seg3.DrawActions = drawActions;
var vg = new MockGraphics();
vg.DrawActions = drawActions;
var site = (MockSite)root.Site;
root.Paint(vg, site.m_transform);
var paintTrans = site.m_transform;
// We should have asked about each run of distinct underlining.
VerifyCharPlacementCall(seg1, 0, "plain".Length, "plain".Length + "underOnYellow".Length,
paintTrans.SourceRect, paintTrans.DestRect, vg, 1);
// para/seg 2
Rect srcRect = paintTrans.SourceRect;
srcRect.top -= para1.Height;
srcRect.bottom -= para1.Height;
VerifyCharPlacementCall(seg2, 0, 0, "doubleRedOnPink".Length,
srcRect, paintTrans.DestRect, vg, 2);
VerifyCharPlacementCall(seg2, 0, "doubleRedOnPink".Length, "doubleRedOnPink".Length + "dotted".Length,
srcRect, paintTrans.DestRect, vg, 1);
VerifyCharPlacementCall(seg2, 0, "doubleRedOnPink".Length + "dotted".Length,
"doubleRedOnPink".Length + "dotted".Length + "dottedOnYellow".Length,
srcRect, paintTrans.DestRect, vg, 1);
// para/seg 3
srcRect.top -= para2.Height;
srcRect.bottom -= para2.Height;
VerifyCharPlacementCall(seg3, 0, 0, "dashed".Length,
srcRect, paintTrans.DestRect, vg, 1);
VerifyCharPlacementCall(seg3, 0, "dashed".Length, "dashed".Length + "dashedRed".Length,
srcRect, paintTrans.DestRect, vg, 1);
VerifyCharPlacementCall(seg3, 0, "dashed".Length + "dashedRed".Length,
"dashed".Length + "dashedRed".Length + "squiggle".Length,
srcRect, paintTrans.DestRect, vg, 1);
// Todo: eventually arrange a run where ichBase is non-zero, and check what happens.
// We want to check a lot of things about the drawing.
// - all the background color and underline drawing should happen before any of the text drawing.
// - the right stuff should be drawn to construct the underlines
// - in particular dotted, dashed, and squiggle underlines should have the gaps and alternations
// aligned, even if in different segments.
// Todo: check actual line segs drawn
int position = 0; // in drawActions
// Normal calls to Draw have the effect of painting the background. All three backgrounds
// should be painted before the foreground. First we paint seg1 with background, since it has some.
VerifyDraw(drawActions, ref position, seg1);
// Next we draw its one horizontal line of underline.
VerifyHorzLine(drawActions, ref position, 10, 20, 15, 1, new int[] { int.MaxValue }, 10);
// Then segment 2's background
VerifyDraw(drawActions, ref position, seg2);
// And various lots of underline: double takes 2 per segment
VerifyHorzLine(drawActions, ref position, 5, 10, 17, 1, new int[] { int.MaxValue }, 5);
VerifyHorzLine(drawActions, ref position, 5, 10, 15, 1, new int[] { int.MaxValue }, 5);
VerifyHorzLine(drawActions, ref position, 15, 20, 18, 1, new int[] { int.MaxValue }, 15);
VerifyHorzLine(drawActions, ref position, 15, 20, 16, 1, new int[] { int.MaxValue }, 15);
// dotted has non-trivial array of dx values (2 pix each)
VerifyHorzLine(drawActions, ref position, 12, 22, 13, 1, new int[] { 2, 2 }, 12);
// dotted has non-trivial array of dx values (2 pix each)
VerifyHorzLine(drawActions, ref position, 30, 41, 12, 1, new int[] { 2, 2 }, 30);
// No background in para 3, doesn't get a draw background call.
//VerifyDraw(drawActions, ref position, seg3);
// But underlines still drawn in the background phase
// Dashed line
VerifyHorzLine(drawActions, ref position, 0, 10, 11, 1, new int[] { 6, 3 }, 0);
VerifyHorzLine(drawActions, ref position, 10, 20, 11, 1, new int[] { 6, 3 }, 10);
// Todo: verify line segs drawn for squiggle.
VerifyLine(drawActions, ref position, 30, 12, 32, 10, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyLine(drawActions, ref position, 32, 10, 34, 12, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyLine(drawActions, ref position, 34, 12, 36, 10, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyLine(drawActions, ref position, 36, 10, 38, 12, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyLine(drawActions, ref position, 38, 12, 40, 10, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyNbDraw(drawActions, ref position, seg1);
VerifyNbDraw(drawActions, ref position, seg2);
VerifyDraw(drawActions, ref position, seg3);
}
public void DrawingBordersandBackground()
{
var root = new RootBoxFdo(new AssembledStyles());
SetupFakeRootSite(root);
var layoutInfo = HookupTests.MakeLayoutInfo(int.MaxValue / 2, m_gm.VwGraphics, 55);
root.RendererFactory = layoutInfo.RendererFactory;
var mock1 = new MockData1() {SimpleThree = "This is the first paragraph."};
// The length of the second paragraph is found by experiment to be enough so that
// despite its lacking borders it also breaks into 2 lines in the second step.
var mock2 = new MockData1() {SimpleThree = "Here is another paragraph. It needs to be a bit longer."};
root.Builder.Show(
Paragraph.Containing(Display.Of(() => mock1.SimpleThree)).BackColor(Color.Red)
.Margins(1.Points(), 2.Points(), 3.Points(), 4.Points())
.Borders(5.Points(), 6.Points(), 7.Points(), 8.Points(), Color.Blue)
.Pads(9.Points(), 10.Points(), 11.Points(), 12.Points()),
Paragraph.Containing(Display.Of(() => mock2.SimpleThree)).BackColor(Color.Yellow)
.Margins(1.Points(), 2.Points(), 3.Points(), 4.Points()));
root.Layout(layoutInfo);
// We want to keep track of the sequence of paint operations in all three segments.
var drawActions = new List<object>();
var vg = new MockGraphics();
vg.DrawActions = drawActions;
var para1 = (ParaBox)root.FirstBox;
var stringbox1 = (StringBox)para1.FirstBox;
var seg1 = (FakeSegment)stringbox1.Segment;
seg1.DrawActions = drawActions;
var para2 = (ParaBox)para1.Next;
var stringbox2 = (StringBox)para2.FirstBox;
var seg2 = (FakeSegment)stringbox2.Segment;
seg2.DrawActions = drawActions;
var site = (MockSite)root.Site;
root.Paint(vg, site.m_transform);
var paintTrans = site.m_transform;
int position = 0;
int red = (int)ColorUtil.ConvertColorToBGR(Color.Red);
int margLeft = layoutInfo.MpToPixelsX(1000);
Assert.That(margLeft, Is.EqualTo(1));
int bordLeft = layoutInfo.MpToPixelsX(5000);
Assert.That(bordLeft, Is.EqualTo(7));
int xOffset = 2 - 100; // how far it is pushed over by the offsets of the layoutInfo
int margTop = layoutInfo.MpToPixelsY(2000);
Assert.That(margTop, Is.EqualTo(3));
int bordTop = layoutInfo.MpToPixelsY(6000);
Assert.That(bordTop, Is.EqualTo(8));
int yOffset = 2 - 200; // how far it is pushed down by the offsets of the layoutInfo
int padLeft = layoutInfo.MpToPixelsX(9000);
Assert.That(padLeft, Is.EqualTo(12));
int padRight = layoutInfo.MpToPixelsX(11000);
Assert.That(padRight, Is.EqualTo(15));
int padTop = layoutInfo.MpToPixelsY(10000);
Assert.That(padTop, Is.EqualTo(13));
int padBottom = layoutInfo.MpToPixelsY(12000);
Assert.That(padBottom, Is.EqualTo(16));
// First it should draw a background rectangle for the first paragraph.
// It is indented by the left margin and the left border, and down by the top margin and border.
// The other side is determined by the size of the embedded box and the two pads.
VerifyRect(drawActions, ref position, margLeft + bordLeft + xOffset, margTop + bordTop + yOffset,
margLeft + bordLeft + xOffset + stringbox1.Width + padLeft + padRight,
margTop + bordTop + yOffset + stringbox1.Height + padTop + padBottom,
red);
int bordBottom = layoutInfo.MpToPixelsY(8000);
Assert.That(bordBottom, Is.EqualTo(11));
int blue = (int)ColorUtil.ConvertColorToBGR(Color.Blue);
// It's arbitrary what order we draw the borders, and I wish the test didn't specify it,
// but in fact the current implementation draws the left border first.
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset,
margLeft + bordLeft + xOffset,
margTop + bordTop + yOffset + padTop + stringbox1.Height + padBottom + bordBottom,
blue);
int bordRight = layoutInfo.MpToPixelsX(7000);
Assert.That(bordRight, Is.EqualTo(9));
// Then the top border
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset,
margLeft + bordLeft + xOffset + padLeft + stringbox1.Width + padRight + bordRight,
margTop + bordTop + yOffset,
blue);
// Then the right border
VerifyRect(drawActions, ref position,
margLeft + bordLeft + xOffset + padLeft + stringbox1.Width + padRight,
margTop + yOffset,
margLeft + bordLeft + xOffset + padLeft + stringbox1.Width + padRight + bordRight,
margTop + bordTop + yOffset + padTop + stringbox1.Height + padBottom + bordBottom,
blue);
// Then the bottom border
VerifyRect(drawActions, ref position,
margLeft + xOffset,
margTop + bordTop + yOffset + padTop + stringbox1.Height + padBottom,
margLeft + bordLeft + xOffset + padLeft + stringbox1.Width + padRight + bordRight,
margTop + bordTop + yOffset + padTop + stringbox1.Height + padBottom + bordBottom,
blue);
// Figure an adjusted y offset for the second paragraph. Everything is down by the height
// of the first paragraph, except that the top and bottom margins overlap by the
// height of the smaller.
int yOffset2 = yOffset + para1.Height - margTop;
int yellow = (int)ColorUtil.ConvertColorToBGR(Color.Yellow);
// Next a background block for the second paragraph.
// (Background color should be reset for the embedded string boxes, so they should not draw their own
// background.)
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset2,
margLeft + xOffset + stringbox2.Width,
margTop + yOffset2 + stringbox2.Height,
yellow);
// Verify the position where the text is drawn
VerifyDraw(drawActions, ref position, seg1, margLeft + bordLeft + padLeft + 2, margTop + bordTop + padTop + 2);
VerifyDraw(drawActions, ref position, seg2, margLeft + 2, para1.Height + 2); //margTop cancels out
// And that should be all!
Assert.That(position, Is.EqualTo(drawActions.Count));
// Verify that multi-lines in a paragraph are appropriately laid out with margin etc.
int maxWidth = para1.Width - FakeRenderEngine.SimulatedWidth("paragraph");
// This maxWidth should force each paragraph to make two segments.
layoutInfo = HookupTests.MakeLayoutInfo(maxWidth, m_gm.VwGraphics, 55);
root.Layout(layoutInfo);
drawActions.Clear();
position = 0;
var stringbox1a = (StringBox)para1.FirstBox;
var seg1a = (FakeSegment)stringbox1a.Segment;
seg1a.DrawActions = drawActions;
var stringbox1b = (StringBox)stringbox1a.Next;
var seg1b = (FakeSegment)stringbox1b.Segment;
seg1b.DrawActions = drawActions;
var stringbox2a = (StringBox)para2.FirstBox;
var seg2a = (FakeSegment)stringbox2a.Segment;
seg2a.DrawActions = drawActions;
var stringbox2b = (StringBox)stringbox2a.Next;
var seg2b = (FakeSegment)stringbox2b.Segment;
seg2b.DrawActions = drawActions;
root.Paint(vg, site.m_transform);
int margRight = layoutInfo.MpToPixelsX(3000);
Assert.That(margRight, Is.EqualTo(4));
// First it should draw a background rectangle for the first paragraph.
// It is indented by the left margin and the left border, and down by the top margin and border.
// The other side is determined by maxWidth minus the right margin and border.
int contentHeight1 = stringbox1a.Height + stringbox1b.Height;
VerifyRect(drawActions, ref position, margLeft + bordLeft + xOffset, margTop + bordTop + yOffset,
maxWidth - margRight - bordRight + xOffset,
margTop + bordTop + yOffset + contentHeight1 + padTop + padBottom,
red);
// It's arbitrary what order we draw the borders, and I wish the test didn't specify it,
// but in fact the current implementation draws the left border first.
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset,
margLeft + bordLeft + xOffset,
margTop + bordTop + yOffset + padTop + contentHeight1 + padBottom + bordBottom,
blue);
// Then the top border
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset,
maxWidth - margRight + xOffset,
margTop + bordTop + yOffset,
blue);
// Then the right border
VerifyRect(drawActions, ref position,
maxWidth - margRight - bordRight + xOffset,
margTop + yOffset,
maxWidth - margRight + xOffset,
margTop + bordTop + yOffset + padTop + contentHeight1 + padBottom + bordBottom,
blue);
// Then the bottom border
VerifyRect(drawActions, ref position,
margLeft + xOffset,
margTop + bordTop + yOffset + padTop + contentHeight1 + padBottom,
maxWidth - margRight + xOffset,
margTop + bordTop + yOffset + padTop + contentHeight1 + padBottom + bordBottom,
blue);
// Figure an adjusted y offset for the second paragraph. Everything is down by the height
// of the first paragraph, except that the top and bottom margins overlap by the
// height of the smaller.
yOffset2 = yOffset + para1.Height - margTop;
// Next a background block for the second paragraph.
// (Background color should be reset for the embedded string boxes, so they should not draw their own
// background.)
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset2,
maxWidth - margRight + xOffset,
margTop + yOffset2 + stringbox2a.Height + stringbox2b.Height,
yellow);
// Verify the position where the text is drawn
VerifyDraw(drawActions, ref position, seg1a, margLeft + bordLeft + padLeft + 2, margTop + bordTop + padTop + 2);
VerifyDraw(drawActions, ref position, seg1b, margLeft + bordLeft + padLeft + 2,
margTop + bordTop + padTop + 2 + stringbox1a.Height);
VerifyDraw(drawActions, ref position, seg2a, margLeft + 2, para1.Height + 2); //margTop cancels out
VerifyDraw(drawActions, ref position, seg2b, margLeft + 2, para1.Height + 2 + stringbox2a.Height); //margTop cancels out
// And that should be all!
Assert.That(position, Is.EqualTo(drawActions.Count));
// A quick check that Relayout puts things in the same places.
drawActions.Clear();
position = 0;
var fixupMap = new Dictionary<Box, Rectangle>();
fixupMap[para1] = new Rectangle(0, 0, 10, 10);
var oldstring1aLeft = stringbox1a.Left;
var oldstring1bTop = stringbox1b.Top;
using (var lcb = new LayoutCallbacks(root))
root.Relayout(layoutInfo, fixupMap, lcb);
Assert.That(drawActions.Count, Is.EqualTo(0));
Assert.That(para1.FirstBox.Left, Is.EqualTo(oldstring1aLeft));
Assert.That(para1.FirstBox.Next.Top, Is.EqualTo(oldstring1bTop));
}
public void PileAndBlock()
{
var root = new RootBoxFdo(new AssembledStyles());
SetupFakeRootSite(root);
var layoutInfo = HookupTests.MakeLayoutInfo(int.MaxValue / 2, m_gm.VwGraphics, 55);
root.RendererFactory = layoutInfo.RendererFactory;
var mock1 = new MockData1() { SimpleThree = "This is the first paragraph." };
// The length of the second paragraph is found by experiment to be enough so that
// despite its lacking borders it also breaks into 2 lines in the second step.
var mock2 = new MockData1() { SimpleThree = "Here is another paragraph. It needs to be a bit longer." };
root.Builder.Show(
Div.Containing(
Display.Block(Color.Red, 25000, 18000).BackColor(Color.Purple)
.Margins(3000, 3000, 3000, 3000)
.Border(5000, Color.Blue)
.Pads(4000, 4000, 4000, 4000),
Display.Block(Color.Green, 25000, 18000)
).BackColor(Color.Pink) // these apply to div.
.Margins(1000, 1000, 1000, 1000)
.Border(2000, Color.Gold)
.Pads(6000, 6000, 6000, 6000));
root.Layout(layoutInfo);
// We want to keep track of the sequence of paint operations in all three segments.
var drawActions = new List<object>();
var vg = new MockGraphics();
vg.DrawActions = drawActions;
var site = (MockSite)root.Site;
root.Paint(vg, site.m_transform);
var paintTrans = site.m_transform;
int position = 0;
int xOffset = 2 - 100; // how far it is pushed over by the offsets of the layoutInfo
int yOffset = 2 - 200; // how far it is pushed down by the offsets of the layoutInfo
int red = (int)ColorUtil.ConvertColorToBGR(Color.Red);
int pink = (int)ColorUtil.ConvertColorToBGR(Color.Pink);
int purple = (int)ColorUtil.ConvertColorToBGR(Color.Purple);
int blue = (int)ColorUtil.ConvertColorToBGR(Color.Blue);
int green = (int)ColorUtil.ConvertColorToBGR(Color.Green);
int gold = (int)ColorUtil.ConvertColorToBGR(Color.Gold);
// Technically we could do different conversions in the two directions, but for this test both dpi are the same.
int margPile = layoutInfo.MpToPixelsX(1000);
int bordPile = layoutInfo.MpToPixelsX(2000);
int padPile = layoutInfo.MpToPixelsX(6000);
int blockWidth = layoutInfo.MpToPixelsX(25000);
int blockHeight = layoutInfo.MpToPixelsX(18000);
int margBlock = layoutInfo.MpToPixelsX(3000);
int bordBlock = layoutInfo.MpToPixelsX(5000);
int padBlock = layoutInfo.MpToPixelsX(4000);
// First a background rectangle for the whole pile.
var leftPilePad = margPile + bordPile + xOffset;
var topPilePad = margPile + bordPile + yOffset;
var rightPilePad = margPile + bordPile + 2 * padPile + blockWidth + 2 * margBlock + 2 * bordBlock + 2 * padBlock + xOffset;
var bottomPilePad = margPile + bordPile + 2 * padPile + 2 * blockHeight + 2 * margBlock + 2 * bordBlock + 2 * padBlock + yOffset;
VerifyRect(drawActions, ref position, leftPilePad, topPilePad, rightPilePad, bottomPilePad, pink);
// Left border, whole pile
VerifyRect(drawActions, ref position, leftPilePad - bordPile, topPilePad - bordPile,
leftPilePad, bottomPilePad + bordPile, gold);
// top border, whole pile
VerifyRect(drawActions, ref position, leftPilePad - bordPile, topPilePad - bordPile,
rightPilePad + bordPile, topPilePad, gold);
// right border, whole pile
VerifyRect(drawActions, ref position, rightPilePad, topPilePad - bordPile,
rightPilePad + bordPile, bottomPilePad + bordPile, gold);
// bottom border, whole pile
VerifyRect(drawActions, ref position, leftPilePad - bordPile, bottomPilePad,
rightPilePad + bordPile, bottomPilePad + bordPile, gold);
// background and border for first block.
var leftBlockPad = margPile + bordPile + padPile + margBlock + bordBlock + xOffset;
var topBlockPad = margPile + bordPile + padPile + margBlock + bordBlock + yOffset;
var rightBlockPad = margPile + bordPile + padPile + margBlock + bordBlock + 2 * padBlock + blockWidth + xOffset;
var bottomBlockPad = margPile + bordPile + padPile + margBlock + bordBlock + 2 * padBlock + blockHeight + yOffset;
VerifyRect(drawActions, ref position, leftBlockPad, topBlockPad, rightBlockPad, bottomBlockPad, purple);
// Left border, whole pile
VerifyRect(drawActions, ref position, leftBlockPad - bordBlock, topBlockPad - bordBlock,
leftBlockPad, bottomBlockPad + bordBlock, blue);
// top border, whole pile
VerifyRect(drawActions, ref position, leftBlockPad - bordBlock, topBlockPad - bordBlock,
rightBlockPad + bordBlock, topBlockPad, blue);
// right border, whole pile
VerifyRect(drawActions, ref position, rightBlockPad, topBlockPad - bordBlock,
rightBlockPad + bordBlock, bottomBlockPad + bordBlock, blue);
// bottom border, whole pile
VerifyRect(drawActions, ref position, leftBlockPad - bordBlock, bottomBlockPad,
rightBlockPad + bordBlock, bottomBlockPad + bordBlock, blue);
// The first block itself.
VerifyRect(drawActions, ref position, leftBlockPad + padBlock, topBlockPad + padBlock,
leftBlockPad + padBlock + blockWidth, topBlockPad + padBlock + blockHeight, red);
// The second block itself.
var topBlock2 = bottomBlockPad + bordBlock + margBlock;
VerifyRect(drawActions, ref position, leftPilePad + padPile, topBlock2,
leftPilePad + padPile + blockWidth, topBlock2 + blockHeight, green);
// And that should be all!
Assert.That(position, Is.EqualTo(drawActions.Count));
// A quick check that Relayout puts things in the same places.
drawActions.Clear();
var fixupMap = new Dictionary<Box, Rectangle>();
var div1 = (DivBox) root.FirstBox;
var block1 = div1.FirstBox;
fixupMap[div1] = new Rectangle(0, 0, 10, 10);
fixupMap[block1] = new Rectangle(0, 0, 10, 10);
var oldblock1Left = block1.Left;
var oldblock1bTop = block1.Top;
using (var lcb = new LayoutCallbacks(root))
root.Relayout(layoutInfo, fixupMap, lcb);
Assert.That(drawActions.Count, Is.EqualTo(0));
Assert.That(div1.FirstBox.Left, Is.EqualTo(oldblock1Left));
Assert.That(div1.FirstBox.Top, Is.EqualTo(oldblock1bTop));
}
void VerifyRect(int x, int y, int width, int height, MockGraphics graphics, int index, Color color)
{
Assert.AreEqual(new Rectangle(x, y, width, height), graphics.RectanglesDrawn[index]);
Assert.AreEqual((int)ColorUtil.ConvertColorToBGR(color), graphics.RectColorsDrawn[index]);
}
public void ValidSelections()
{
AssembledStyles styles = new AssembledStyles();
var clientRuns = new List<IClientRun>();
var run0 = new StringClientRun("First run", styles);
var run1 = new StringClientRun("Middle run", styles);
BlockBox box0 = new BlockBox(styles, Color.Red, 72000, 36000);
var run2 = new StringClientRun("Last run", styles);
clientRuns.Add(run0);
clientRuns.Add(run1);
clientRuns.Add(box0);
clientRuns.Add(run2);
TextSource source = new TextSource(clientRuns, null);
ParaBox para0 = new ParaBox(styles, source);
run0.Hookup = new LiteralStringParaHookup(para0, para0);
run1.Hookup = new LiteralStringParaHookup(para0, para0);
run2.Hookup = new LiteralStringParaHookup(para0, para0);
DivBox div = new DivBox(styles);
RootBox root = new RootBox(styles);
para0.Container = div;
MockGraphics graphics = new MockGraphics();
LayoutInfo layoutArgs = ParaBuilderTests.MakeLayoutInfo(100, graphics);
root.Layout(layoutArgs);
root.AddBox(div);
var sel = para0.SelectAtStart();
root.Selection = sel;
Assert.That(!root.Selection.IsValid);
div.AddBox(para0);
root.RemoveBoxes(div, div);
div.Container = root;
Assert.That(!root.Selection.IsValid);
root.AddBox(div);
Assert.That(root.Selection.IsValid);
(root.Selection as InsertionPoint).Hookup.ClientRunIndex = 4;
Assert.That(!root.Selection.IsValid);
(root.Selection as InsertionPoint).Hookup.ClientRunIndex = 2;
Assert.That(!root.Selection.IsValid);
(root.Selection as InsertionPoint).Hookup.ClientRunIndex = 0;
(root.Selection as InsertionPoint).StringPosition = 10;
Assert.That(!root.Selection.IsValid);
(root.Selection as InsertionPoint).StringPosition = 0;
run0.Hookup = null;
Assert.That(!root.Selection.IsValid);
run0.Hookup = new LiteralStringParaHookup(para0, para0);
sel = para0.SelectAtStart();
root.Selection = sel;
Assert.That(root.Selection.IsValid);
}
public void BackgroundAndUnderlinePainting()
{
var styles = new AssembledStyles();
RootBox root = new RootBoxFdo(styles);
SetupFakeRootSite(root);
var layoutInfo = HookupTests.MakeLayoutInfo(int.MaxValue / 2, m_gm.VwGraphics, 55);
root.RendererFactory = layoutInfo.RendererFactory;
root.Builder.Show(
Paragraph.Containing(
Display.Of("plain"),
Display.Of("underOnYellow").Underline(FwUnderlineType.kuntSingle).BackColor(Color.Yellow)
),
Paragraph.Containing(
Display.Of("doubleRedOnPink").Underline(FwUnderlineType.kuntDouble, Color.Red).BackColor(Color.Pink),
Display.Of("dotted").Underline(FwUnderlineType.kuntDotted),
Display.Of("dottedOnYellow").Underline(FwUnderlineType.kuntDotted).BackColor(Color.Yellow)
),
Paragraph.Containing(
Display.Of("dashed").Underline(FwUnderlineType.kuntDashed),
Display.Of("dashedRed").Underline(FwUnderlineType.kuntDashed).ForeColor(Color.Red),
Display.Of("squiggle").Underline(FwUnderlineType.kuntSquiggle)
)
);
root.Layout(layoutInfo);
var para1 = (ParaBox)root.FirstBox;
var stringBox1 = (StringBox)para1.FirstBox;
var seg1 = (FakeSegment)stringBox1.Segment;
// A convenient place to test that literals get Chrp with default user ws.
LgCharRenderProps chrp;
int ichMin, ichLim;
para1.Source.GetCharProps(0, out chrp, out ichMin, out ichLim);
Assert.That(chrp.ws, Is.EqualTo(layoutInfo.RendererFactory.UserWs));
// This segment has just one chunk of underline, the second run.
seg1.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{Lefts = new[] {10}, Rights = new[] {20}, Tops = new[] {15}});
// Todo: add expectations for each run of underlining.
var para2 = (ParaBox)para1.Next;
var stringBox2 = (StringBox)para2.FirstBox;
var seg2 = (FakeSegment)stringBox2.Segment;
// For the double red underline, we'll pretend there are two line segments.
seg2.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{ Lefts = new[] { 5, 15 }, Rights = new[] { 10, 20 }, Tops = new[] { 15, 16 } });
seg2.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{ Lefts = new[] { 12 }, Rights = new[] { 22 }, Tops = new[] { 13 } });
seg2.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{ Lefts = new[] { 30 }, Rights = new[] { 41 }, Tops = new[] { 12 } });
var para3 = (ParaBox)para2.Next;
var stringBox3 = (StringBox)para3.FirstBox;
var seg3 = (FakeSegment)stringBox3.Segment;
seg3.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{ Lefts = new[] { 0 }, Rights = new[] { 10 }, Tops = new[] { 11 } });
seg3.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{ Lefts = new[] { 10 }, Rights = new[] { 20 }, Tops = new[] { 11 } });
seg3.NextCharPlacementResults.Add(new FakeSegment.CharPlacementResults()
{ Lefts = new[] { 30 }, Rights = new[] { 40 }, Tops = new[] { 11 } });
// We want to keep track of the sequence of paint operations in all three segments.
var drawActions = new List<object>();
seg1.DrawActions = seg2.DrawActions = seg3.DrawActions = drawActions;
var vg = new MockGraphics();
vg.DrawActions = drawActions;
var site = (MockSite)root.Site;
root.Paint(vg, site.m_transform);
var paintTrans = site.m_transform;
// We should have asked about each run of distinct underlining.
VerifyCharPlacementCall(seg1, 0, "plain".Length, "plain".Length + "underOnYellow".Length,
paintTrans.SourceRect, paintTrans.DestRect, vg, 1);
// para/seg 2
Rect srcRect = paintTrans.SourceRect;
srcRect.top -= para1.Height;
srcRect.bottom -= para1.Height;
VerifyCharPlacementCall(seg2, 0, 0, "doubleRedOnPink".Length,
srcRect, paintTrans.DestRect, vg, 2);
VerifyCharPlacementCall(seg2, 0, "doubleRedOnPink".Length, "doubleRedOnPink".Length + "dotted".Length,
srcRect, paintTrans.DestRect, vg, 1);
VerifyCharPlacementCall(seg2, 0, "doubleRedOnPink".Length + "dotted".Length,
"doubleRedOnPink".Length + "dotted".Length + "dottedOnYellow".Length,
srcRect, paintTrans.DestRect, vg, 1);
// para/seg 3
srcRect.top -= para2.Height;
srcRect.bottom -= para2.Height;
VerifyCharPlacementCall(seg3, 0, 0, "dashed".Length,
srcRect, paintTrans.DestRect, vg, 1);
VerifyCharPlacementCall(seg3, 0, "dashed".Length, "dashed".Length + "dashedRed".Length,
srcRect, paintTrans.DestRect, vg, 1);
VerifyCharPlacementCall(seg3, 0, "dashed".Length + "dashedRed".Length,
"dashed".Length + "dashedRed".Length + "squiggle".Length,
srcRect, paintTrans.DestRect, vg, 1);
// Todo: eventually arrange a run where ichBase is non-zero, and check what happens.
// We want to check a lot of things about the drawing.
// - all the background color and underline drawing should happen before any of the text drawing.
// - the right stuff should be drawn to construct the underlines
// - in particular dotted, dashed, and squiggle underlines should have the gaps and alternations
// aligned, even if in different segments.
// Todo: check actual line segs drawn
int position = 0; // in drawActions
// Normal calls to Draw have the effect of painting the background. All three backgrounds
// should be painted before the foreground. First we paint seg1 with background, since it has some.
VerifyDraw(drawActions, ref position, seg1);
// Next we draw its one horizontal line of underline.
VerifyHorzLine(drawActions, ref position, 10, 20, 15, 1, new int[] {int.MaxValue}, 10);
// Then segment 2's background
VerifyDraw(drawActions, ref position, seg2);
// And various lots of underline: double takes 2 per segment
VerifyHorzLine(drawActions, ref position, 5, 10, 17, 1, new int[] { int.MaxValue }, 5);
VerifyHorzLine(drawActions, ref position, 5, 10, 15, 1, new int[] { int.MaxValue }, 5);
VerifyHorzLine(drawActions, ref position, 15, 20, 18, 1, new int[] { int.MaxValue }, 15);
VerifyHorzLine(drawActions, ref position, 15, 20, 16, 1, new int[] { int.MaxValue }, 15);
// dotted has non-trivial array of dx values (2 pix each)
VerifyHorzLine(drawActions, ref position, 12, 22, 13, 1, new int[] { 2, 2 }, 12);
// dotted has non-trivial array of dx values (2 pix each)
VerifyHorzLine(drawActions, ref position, 30, 41, 12, 1, new int[] { 2, 2 }, 30);
// No background in para 3, doesn't get a draw background call.
//VerifyDraw(drawActions, ref position, seg3);
// But underlines still drawn in the background phase
// Dashed line
VerifyHorzLine(drawActions, ref position, 0, 10, 11, 1, new int[] { 6, 3 }, 0);
VerifyHorzLine(drawActions, ref position, 10, 20, 11, 1, new int[] { 6, 3 }, 10);
// Todo: verify line segs drawn for squiggle.
VerifyLine(drawActions, ref position, 30, 12, 32, 10, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyLine(drawActions, ref position, 32, 10, 34, 12, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyLine(drawActions, ref position, 34, 12, 36, 10, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyLine(drawActions, ref position, 36, 10, 38, 12, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyLine(drawActions, ref position, 38, 12, 40, 10, ColorUtil.ConvertColorToBGR(Color.Black));
VerifyNbDraw(drawActions, ref position, seg1);
VerifyNbDraw(drawActions, ref position, seg2);
VerifyDraw(drawActions, ref position, seg3);
}
public void DrawingBordersandBackground()
{
var root = new RootBoxFdo(new AssembledStyles());
SetupFakeRootSite(root);
var layoutInfo = HookupTests.MakeLayoutInfo(int.MaxValue / 2, m_gm.VwGraphics, 55);
root.RendererFactory = layoutInfo.RendererFactory;
var mock1 = new MockData1()
{
SimpleThree = "This is the first paragraph."
};
// The length of the second paragraph is found by experiment to be enough so that
// despite its lacking borders it also breaks into 2 lines in the second step.
var mock2 = new MockData1()
{
SimpleThree = "Here is another paragraph. It needs to be a bit longer."
};
root.Builder.Show(
Paragraph.Containing(Display.Of(() => mock1.SimpleThree)).BackColor(Color.Red)
.Margins(1.Points(), 2.Points(), 3.Points(), 4.Points())
.Borders(5.Points(), 6.Points(), 7.Points(), 8.Points(), Color.Blue)
.Pads(9.Points(), 10.Points(), 11.Points(), 12.Points()),
Paragraph.Containing(Display.Of(() => mock2.SimpleThree)).BackColor(Color.Yellow)
.Margins(1.Points(), 2.Points(), 3.Points(), 4.Points()));
root.Layout(layoutInfo);
// We want to keep track of the sequence of paint operations in all three segments.
var drawActions = new List <object>();
var vg = new MockGraphics();
vg.DrawActions = drawActions;
var para1 = (ParaBox)root.FirstBox;
var stringbox1 = (StringBox)para1.FirstBox;
var seg1 = (FakeSegment)stringbox1.Segment;
seg1.DrawActions = drawActions;
var para2 = (ParaBox)para1.Next;
var stringbox2 = (StringBox)para2.FirstBox;
var seg2 = (FakeSegment)stringbox2.Segment;
seg2.DrawActions = drawActions;
var site = (MockSite)root.Site;
root.Paint(vg, site.m_transform);
var paintTrans = site.m_transform;
int position = 0;
int red = (int)ColorUtil.ConvertColorToBGR(Color.Red);
int margLeft = layoutInfo.MpToPixelsX(1000);
Assert.That(margLeft, Is.EqualTo(1));
int bordLeft = layoutInfo.MpToPixelsX(5000);
Assert.That(bordLeft, Is.EqualTo(7));
int xOffset = 2 - 100; // how far it is pushed over by the offsets of the layoutInfo
int margTop = layoutInfo.MpToPixelsY(2000);
Assert.That(margTop, Is.EqualTo(3));
int bordTop = layoutInfo.MpToPixelsY(6000);
Assert.That(bordTop, Is.EqualTo(8));
int yOffset = 2 - 200; // how far it is pushed down by the offsets of the layoutInfo
int padLeft = layoutInfo.MpToPixelsX(9000);
Assert.That(padLeft, Is.EqualTo(12));
int padRight = layoutInfo.MpToPixelsX(11000);
Assert.That(padRight, Is.EqualTo(15));
int padTop = layoutInfo.MpToPixelsY(10000);
Assert.That(padTop, Is.EqualTo(13));
int padBottom = layoutInfo.MpToPixelsY(12000);
Assert.That(padBottom, Is.EqualTo(16));
// First it should draw a background rectangle for the first paragraph.
// It is indented by the left margin and the left border, and down by the top margin and border.
// The other side is determined by the size of the embedded box and the two pads.
VerifyRect(drawActions, ref position, margLeft + bordLeft + xOffset, margTop + bordTop + yOffset,
margLeft + bordLeft + xOffset + stringbox1.Width + padLeft + padRight,
margTop + bordTop + yOffset + stringbox1.Height + padTop + padBottom,
red);
int bordBottom = layoutInfo.MpToPixelsY(8000);
Assert.That(bordBottom, Is.EqualTo(11));
int blue = (int)ColorUtil.ConvertColorToBGR(Color.Blue);
// It's arbitrary what order we draw the borders, and I wish the test didn't specify it,
// but in fact the current implementation draws the left border first.
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset,
margLeft + bordLeft + xOffset,
margTop + bordTop + yOffset + padTop + stringbox1.Height + padBottom + bordBottom,
blue);
int bordRight = layoutInfo.MpToPixelsX(7000);
Assert.That(bordRight, Is.EqualTo(9));
// Then the top border
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset,
margLeft + bordLeft + xOffset + padLeft + stringbox1.Width + padRight + bordRight,
margTop + bordTop + yOffset,
blue);
// Then the right border
VerifyRect(drawActions, ref position,
margLeft + bordLeft + xOffset + padLeft + stringbox1.Width + padRight,
margTop + yOffset,
margLeft + bordLeft + xOffset + padLeft + stringbox1.Width + padRight + bordRight,
margTop + bordTop + yOffset + padTop + stringbox1.Height + padBottom + bordBottom,
blue);
// Then the bottom border
VerifyRect(drawActions, ref position,
margLeft + xOffset,
margTop + bordTop + yOffset + padTop + stringbox1.Height + padBottom,
margLeft + bordLeft + xOffset + padLeft + stringbox1.Width + padRight + bordRight,
margTop + bordTop + yOffset + padTop + stringbox1.Height + padBottom + bordBottom,
blue);
// Figure an adjusted y offset for the second paragraph. Everything is down by the height
// of the first paragraph, except that the top and bottom margins overlap by the
// height of the smaller.
int yOffset2 = yOffset + para1.Height - margTop;
int yellow = (int)ColorUtil.ConvertColorToBGR(Color.Yellow);
// Next a background block for the second paragraph.
// (Background color should be reset for the embedded string boxes, so they should not draw their own
// background.)
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset2,
margLeft + xOffset + stringbox2.Width,
margTop + yOffset2 + stringbox2.Height,
yellow);
// Verify the position where the text is drawn
VerifyDraw(drawActions, ref position, seg1, margLeft + bordLeft + padLeft + 2, margTop + bordTop + padTop + 2);
VerifyDraw(drawActions, ref position, seg2, margLeft + 2, para1.Height + 2); //margTop cancels out
// And that should be all!
Assert.That(position, Is.EqualTo(drawActions.Count));
// Verify that multi-lines in a paragraph are appropriately laid out with margin etc.
int maxWidth = para1.Width - FakeRenderEngine.SimulatedWidth("paragraph");
// This maxWidth should force each paragraph to make two segments.
layoutInfo = HookupTests.MakeLayoutInfo(maxWidth, m_gm.VwGraphics, 55);
root.Layout(layoutInfo);
drawActions.Clear();
position = 0;
var stringbox1a = (StringBox)para1.FirstBox;
var seg1a = (FakeSegment)stringbox1a.Segment;
seg1a.DrawActions = drawActions;
var stringbox1b = (StringBox)stringbox1a.Next;
var seg1b = (FakeSegment)stringbox1b.Segment;
seg1b.DrawActions = drawActions;
var stringbox2a = (StringBox)para2.FirstBox;
var seg2a = (FakeSegment)stringbox2a.Segment;
seg2a.DrawActions = drawActions;
var stringbox2b = (StringBox)stringbox2a.Next;
var seg2b = (FakeSegment)stringbox2b.Segment;
seg2b.DrawActions = drawActions;
root.Paint(vg, site.m_transform);
int margRight = layoutInfo.MpToPixelsX(3000);
Assert.That(margRight, Is.EqualTo(4));
// First it should draw a background rectangle for the first paragraph.
// It is indented by the left margin and the left border, and down by the top margin and border.
// The other side is determined by maxWidth minus the right margin and border.
int contentHeight1 = stringbox1a.Height + stringbox1b.Height;
VerifyRect(drawActions, ref position, margLeft + bordLeft + xOffset, margTop + bordTop + yOffset,
maxWidth - margRight - bordRight + xOffset,
margTop + bordTop + yOffset + contentHeight1 + padTop + padBottom,
red);
// It's arbitrary what order we draw the borders, and I wish the test didn't specify it,
// but in fact the current implementation draws the left border first.
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset,
margLeft + bordLeft + xOffset,
margTop + bordTop + yOffset + padTop + contentHeight1 + padBottom + bordBottom,
blue);
// Then the top border
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset,
maxWidth - margRight + xOffset,
margTop + bordTop + yOffset,
blue);
// Then the right border
VerifyRect(drawActions, ref position,
maxWidth - margRight - bordRight + xOffset,
margTop + yOffset,
maxWidth - margRight + xOffset,
margTop + bordTop + yOffset + padTop + contentHeight1 + padBottom + bordBottom,
blue);
// Then the bottom border
VerifyRect(drawActions, ref position,
margLeft + xOffset,
margTop + bordTop + yOffset + padTop + contentHeight1 + padBottom,
maxWidth - margRight + xOffset,
margTop + bordTop + yOffset + padTop + contentHeight1 + padBottom + bordBottom,
blue);
// Figure an adjusted y offset for the second paragraph. Everything is down by the height
// of the first paragraph, except that the top and bottom margins overlap by the
// height of the smaller.
yOffset2 = yOffset + para1.Height - margTop;
// Next a background block for the second paragraph.
// (Background color should be reset for the embedded string boxes, so they should not draw their own
// background.)
VerifyRect(drawActions, ref position, margLeft + xOffset, margTop + yOffset2,
maxWidth - margRight + xOffset,
margTop + yOffset2 + stringbox2a.Height + stringbox2b.Height,
yellow);
// Verify the position where the text is drawn
VerifyDraw(drawActions, ref position, seg1a, margLeft + bordLeft + padLeft + 2, margTop + bordTop + padTop + 2);
VerifyDraw(drawActions, ref position, seg1b, margLeft + bordLeft + padLeft + 2,
margTop + bordTop + padTop + 2 + stringbox1a.Height);
VerifyDraw(drawActions, ref position, seg2a, margLeft + 2, para1.Height + 2); //margTop cancels out
VerifyDraw(drawActions, ref position, seg2b, margLeft + 2, para1.Height + 2 + stringbox2a.Height); //margTop cancels out
// And that should be all!
Assert.That(position, Is.EqualTo(drawActions.Count));
// A quick check that Relayout puts things in the same places.
drawActions.Clear();
position = 0;
var fixupMap = new Dictionary <Box, Rectangle>();
fixupMap[para1] = new Rectangle(0, 0, 10, 10);
var oldstring1aLeft = stringbox1a.Left;
var oldstring1bTop = stringbox1b.Top;
using (var lcb = new LayoutCallbacks(root))
root.Relayout(layoutInfo, fixupMap, lcb);
Assert.That(drawActions.Count, Is.EqualTo(0));
Assert.That(para1.FirstBox.Left, Is.EqualTo(oldstring1aLeft));
Assert.That(para1.FirstBox.Next.Top, Is.EqualTo(oldstring1bTop));
}
void VerifyRect(int x, int y, int width, int height, MockGraphics graphics, int index, Color color)
{
Assert.AreEqual(new Rectangle(x, y, width, height), graphics.RectanglesDrawn[index]);
Assert.AreEqual((int)ColorUtil.ConvertColorToBGR(color), graphics.RectColorsDrawn[index]);
}
public void FlashInsertionPoint()
{
AssembledStyles styles = new AssembledStyles();
var clientRuns = new List <IClientRun>();
BlockBox box0 = new BlockBox(styles, Color.Red, 72000, 36000);
clientRuns.Add(box0);
TextSource source = new TextSource(clientRuns, null);
ParaBox para = new ParaBox(styles, source);
RootBox root = new RootBox(styles);
root.AddBox(para);
MockGraphics graphics = new MockGraphics();
LayoutInfo layoutArgs = ParaBuilderTests.MakeLayoutInfo(100, graphics);
root.Layout(layoutArgs);
var sel = new DummySelection();
root.Selection = sel;
PaintTransform ptrans = new PaintTransform(2, 2, 96, 96, 0, 0, 96, 96);
root.Paint(graphics, ptrans);
Assert.AreEqual(graphics, sel.VgUsedToDraw);
Assert.AreEqual(ptrans, sel.TransformUsedToDraw);
sel.ClearResults();
root.FlashInsertionPoint();
Assert.IsFalse(sel.WasInvalidated, "flash IP should not cause range to be invalidated");
var ip = new DummySelection();
ip.SimulateIP = true;
root.Selection = ip;
Assert.IsTrue(ip.WasInvalidated);
// Initial paint after being installed should indeed paint the IP (so it appears at once)
ip.ClearResults();
root.Paint(graphics, ptrans);
Assert.AreEqual(graphics, ip.VgUsedToDraw);
Assert.AreEqual(ptrans, ip.TransformUsedToDraw);
// Each flash should invalide it.
sel.ClearResults();
root.FlashInsertionPoint();
Assert.IsTrue(ip.WasInvalidated);
// The second paint should do nothing to the IP.
ip.ClearResults();
root.Paint(graphics, ptrans);
Assert.AreEqual(null, ip.VgUsedToDraw);
// One more flash
ip.ClearResults();
root.FlashInsertionPoint();
Assert.IsTrue(ip.WasInvalidated);
// And now back to drawing the IP.
ip.ClearResults();
root.Paint(graphics, ptrans);
Assert.AreEqual(graphics, ip.VgUsedToDraw);
Assert.AreEqual(ptrans, ip.TransformUsedToDraw);
// range should get drawn even though IP was hidden.
root.FlashInsertionPoint(); // back to hidden
root.Selection = sel; // back to range.
sel.ClearResults();
root.Paint(graphics, ptrans);
Assert.AreEqual(graphics, sel.VgUsedToDraw);
Assert.AreEqual(ptrans, sel.TransformUsedToDraw);
}
public void ValidSelections()
{
AssembledStyles styles = new AssembledStyles();
var clientRuns = new List <IClientRun>();
var run0 = new StringClientRun("First run", styles);
var run1 = new StringClientRun("Middle run", styles);
BlockBox box0 = new BlockBox(styles, Color.Red, 72000, 36000);
var run2 = new StringClientRun("Last run", styles);
clientRuns.Add(run0);
clientRuns.Add(run1);
clientRuns.Add(box0);
clientRuns.Add(run2);
TextSource source = new TextSource(clientRuns, null);
ParaBox para0 = new ParaBox(styles, source);
run0.Hookup = new LiteralStringParaHookup(para0, para0);
run1.Hookup = new LiteralStringParaHookup(para0, para0);
run2.Hookup = new LiteralStringParaHookup(para0, para0);
DivBox div = new DivBox(styles);
RootBox root = new RootBox(styles);
para0.Container = div;
MockGraphics graphics = new MockGraphics();
LayoutInfo layoutArgs = ParaBuilderTests.MakeLayoutInfo(100, graphics);
root.Layout(layoutArgs);
root.AddBox(div);
var sel = para0.SelectAtStart();
root.Selection = sel;
Assert.That(!root.Selection.IsValid);
div.AddBox(para0);
root.RemoveBoxes(div, div);
div.Container = root;
Assert.That(!root.Selection.IsValid);
root.AddBox(div);
Assert.That(root.Selection.IsValid);
(root.Selection as InsertionPoint).Hookup.ClientRunIndex = 4;
Assert.That(!root.Selection.IsValid);
(root.Selection as InsertionPoint).Hookup.ClientRunIndex = 2;
Assert.That(!root.Selection.IsValid);
(root.Selection as InsertionPoint).Hookup.ClientRunIndex = 0;
(root.Selection as InsertionPoint).StringPosition = 10;
Assert.That(!root.Selection.IsValid);
(root.Selection as InsertionPoint).StringPosition = 0;
run0.Hookup = null;
Assert.That(!root.Selection.IsValid);
run0.Hookup = new LiteralStringParaHookup(para0, para0);
sel = para0.SelectAtStart();
root.Selection = sel;
Assert.That(root.Selection.IsValid);
}
public void PaintPictureBox()
{
AssembledStyles styles = new AssembledStyles();
Bitmap bm = new Bitmap(20, 30);
ImageBox box = new ImageBox(styles.WithMargins(new Thickness(72.0 / 96.0 * 2.0))
.WithBorders(new Thickness(72.0 / 96.0 * 3.0))
.WithPads(new Thickness(72.0 / 96.0 * 7.0, 72.0 / 96.0 * 8.0, 72.0 / 96.0 * 11.0, 72.0 / 96.0 * 13.0)), bm);
RootBox root = new RootBox(styles);
BlockBox block = new BlockBox(styles, Color.Yellow, 2000, 4000);
root.AddBox(block);
root.AddBox(box);
LayoutInfo transform = MakeLayoutInfo();
root.Layout(transform);
Assert.That(box.Height, Is.EqualTo(30 + 2*2+3*2+8+13));
Assert.That(box.Width, Is.EqualTo(20 + 2*2 +3*2 + 7 + 11));
Assert.That(box.Ascent, Is.EqualTo(box.Height));
PaintTransform ptrans = new PaintTransform(2, 4, 96, 96, 10, 40, 96, 96);
MockGraphics graphics = new MockGraphics();
root.Paint(graphics, ptrans);
Assert.That(graphics.LastRenderPictureArgs, Is.Not.Null);
Assert.That(graphics.LastRenderPictureArgs.Picture, Is.EqualTo(box.Picture));
Assert.That(graphics.LastRenderPictureArgs.X, Is.EqualTo(2-10 + 2 + 3 + 7));
Assert.That(graphics.LastRenderPictureArgs.Y, Is.EqualTo(4 - 40 + block.Height + 2 + 3 + 8));
Assert.That(graphics.LastRenderPictureArgs.Cx, Is.EqualTo(20));
Assert.That(graphics.LastRenderPictureArgs.Cy, Is.EqualTo(30));
int hmWidth = box.Picture.Width;
int hmHeight = box.Picture.Height;
Assert.That(graphics.LastRenderPictureArgs.XSrc, Is.EqualTo(0));
Assert.That(graphics.LastRenderPictureArgs.YSrc, Is.EqualTo(hmHeight));
Assert.That(graphics.LastRenderPictureArgs.CxSrc, Is.EqualTo(hmWidth));
Assert.That(graphics.LastRenderPictureArgs.CySrc, Is.EqualTo(-hmHeight));
Assert.That(graphics.LastRenderPictureArgs.RcWBounds.left, Is.EqualTo(2 - 10 + 2 + 3 + 7));
Assert.That(graphics.LastRenderPictureArgs.RcWBounds.top, Is.EqualTo(4 - 40 + block.Height + 2 + 3 + 8));
Assert.That(graphics.LastRenderPictureArgs.RcWBounds.right, Is.EqualTo(2 - 10 + 2 + 3 + 7 + 20));
Assert.That(graphics.LastRenderPictureArgs.RcWBounds.bottom, Is.EqualTo(4 - 40 + block.Height + 2 + 3 + 8 + 30));
}
public void FlashInsertionPoint()
{
AssembledStyles styles = new AssembledStyles();
var clientRuns = new List<IClientRun>();
BlockBox box0 = new BlockBox(styles, Color.Red, 72000, 36000);
clientRuns.Add(box0);
TextSource source = new TextSource(clientRuns, null);
ParaBox para = new ParaBox(styles, source);
RootBox root = new RootBox(styles);
root.AddBox(para);
MockGraphics graphics = new MockGraphics();
LayoutInfo layoutArgs = ParaBuilderTests.MakeLayoutInfo(100, graphics);
root.Layout(layoutArgs);
var sel = new DummySelection();
root.Selection = sel;
PaintTransform ptrans = new PaintTransform(2, 2, 96, 96, 0, 0, 96, 96);
root.Paint(graphics, ptrans);
Assert.AreEqual(graphics, sel.VgUsedToDraw);
Assert.AreEqual(ptrans, sel.TransformUsedToDraw);
sel.ClearResults();
root.FlashInsertionPoint();
Assert.IsFalse(sel.WasInvalidated, "flash IP should not cause range to be invalidated");
var ip = new DummySelection();
ip.SimulateIP = true;
root.Selection = ip;
Assert.IsTrue(ip.WasInvalidated);
// Initial paint after being installed should indeed paint the IP (so it appears at once)
ip.ClearResults();
root.Paint(graphics, ptrans);
Assert.AreEqual(graphics, ip.VgUsedToDraw);
Assert.AreEqual(ptrans, ip.TransformUsedToDraw);
// Each flash should invalide it.
sel.ClearResults();
root.FlashInsertionPoint();
Assert.IsTrue(ip.WasInvalidated);
// The second paint should do nothing to the IP.
ip.ClearResults();
root.Paint(graphics, ptrans);
Assert.AreEqual(null, ip.VgUsedToDraw);
// One more flash
ip.ClearResults();
root.FlashInsertionPoint();
Assert.IsTrue(ip.WasInvalidated);
// And now back to drawing the IP.
ip.ClearResults();
root.Paint(graphics, ptrans);
Assert.AreEqual(graphics, ip.VgUsedToDraw);
Assert.AreEqual(ptrans, ip.TransformUsedToDraw);
// range should get drawn even though IP was hidden.
root.FlashInsertionPoint(); // back to hidden
root.Selection = sel; // back to range.
sel.ClearResults();
root.Paint(graphics, ptrans);
Assert.AreEqual(graphics, sel.VgUsedToDraw);
Assert.AreEqual(ptrans, sel.TransformUsedToDraw);
}
private void VerifyPaint(RootBox root, Rectangle clipRect, int xScrollOffset, int yScrollOffset, Rectangle[] paintRects)
{
MockGraphics graphics = new MockGraphics();
graphics.ClipRectangle = clipRect;
PaintTransform ptrans = new PaintTransform(0, 0, 96, 96, xScrollOffset, yScrollOffset, 96, 96);
root.Paint(graphics, ptrans);
var drawActions = graphics.DrawActions; // after the paint, it gets created when first rect added.
if (paintRects == null || paintRects.Length == 0)
{
Assert.IsTrue(drawActions == null || drawActions.Count == 0);
return;
}
Assert.That(drawActions, Has.Count.EqualTo(paintRects.Length * 2));
int position = 0;
// First all the blocks get drawn in their PaintBackground routine
foreach (var rect in paintRects)
{
VerifyRect(drawActions, ref position, rect);
}
// Then we verify that the PaintForeground routines got called.
for (; position < drawActions.Count; position++)
Assert.That(drawActions[position], Is.InstanceOf(typeof(FgBlockBox)));
}
public void PileAndBlock()
{
var root = new RootBoxFdo(new AssembledStyles());
SetupFakeRootSite(root);
var layoutInfo = HookupTests.MakeLayoutInfo(int.MaxValue / 2, m_gm.VwGraphics, 55);
root.RendererFactory = layoutInfo.RendererFactory;
var mock1 = new MockData1()
{
SimpleThree = "This is the first paragraph."
};
// The length of the second paragraph is found by experiment to be enough so that
// despite its lacking borders it also breaks into 2 lines in the second step.
var mock2 = new MockData1()
{
SimpleThree = "Here is another paragraph. It needs to be a bit longer."
};
root.Builder.Show(
Div.Containing(
Display.Block(Color.Red, 25000, 18000).BackColor(Color.Purple)
.Margins(3000, 3000, 3000, 3000)
.Border(5000, Color.Blue)
.Pads(4000, 4000, 4000, 4000),
Display.Block(Color.Green, 25000, 18000)
).BackColor(Color.Pink) // these apply to div.
.Margins(1000, 1000, 1000, 1000)
.Border(2000, Color.Gold)
.Pads(6000, 6000, 6000, 6000));
root.Layout(layoutInfo);
// We want to keep track of the sequence of paint operations in all three segments.
var drawActions = new List <object>();
var vg = new MockGraphics();
vg.DrawActions = drawActions;
var site = (MockSite)root.Site;
root.Paint(vg, site.m_transform);
var paintTrans = site.m_transform;
int position = 0;
int xOffset = 2 - 100; // how far it is pushed over by the offsets of the layoutInfo
int yOffset = 2 - 200; // how far it is pushed down by the offsets of the layoutInfo
int red = (int)ColorUtil.ConvertColorToBGR(Color.Red);
int pink = (int)ColorUtil.ConvertColorToBGR(Color.Pink);
int purple = (int)ColorUtil.ConvertColorToBGR(Color.Purple);
int blue = (int)ColorUtil.ConvertColorToBGR(Color.Blue);
int green = (int)ColorUtil.ConvertColorToBGR(Color.Green);
int gold = (int)ColorUtil.ConvertColorToBGR(Color.Gold);
// Technically we could do different conversions in the two directions, but for this test both dpi are the same.
int margPile = layoutInfo.MpToPixelsX(1000);
int bordPile = layoutInfo.MpToPixelsX(2000);
int padPile = layoutInfo.MpToPixelsX(6000);
int blockWidth = layoutInfo.MpToPixelsX(25000);
int blockHeight = layoutInfo.MpToPixelsX(18000);
int margBlock = layoutInfo.MpToPixelsX(3000);
int bordBlock = layoutInfo.MpToPixelsX(5000);
int padBlock = layoutInfo.MpToPixelsX(4000);
// First a background rectangle for the whole pile.
var leftPilePad = margPile + bordPile + xOffset;
var topPilePad = margPile + bordPile + yOffset;
var rightPilePad = margPile + bordPile + 2 * padPile + blockWidth + 2 * margBlock + 2 * bordBlock + 2 * padBlock + xOffset;
var bottomPilePad = margPile + bordPile + 2 * padPile + 2 * blockHeight + 2 * margBlock + 2 * bordBlock + 2 * padBlock + yOffset;
VerifyRect(drawActions, ref position, leftPilePad, topPilePad, rightPilePad, bottomPilePad, pink);
// Left border, whole pile
VerifyRect(drawActions, ref position, leftPilePad - bordPile, topPilePad - bordPile,
leftPilePad, bottomPilePad + bordPile, gold);
// top border, whole pile
VerifyRect(drawActions, ref position, leftPilePad - bordPile, topPilePad - bordPile,
rightPilePad + bordPile, topPilePad, gold);
// right border, whole pile
VerifyRect(drawActions, ref position, rightPilePad, topPilePad - bordPile,
rightPilePad + bordPile, bottomPilePad + bordPile, gold);
// bottom border, whole pile
VerifyRect(drawActions, ref position, leftPilePad - bordPile, bottomPilePad,
rightPilePad + bordPile, bottomPilePad + bordPile, gold);
// background and border for first block.
var leftBlockPad = margPile + bordPile + padPile + margBlock + bordBlock + xOffset;
var topBlockPad = margPile + bordPile + padPile + margBlock + bordBlock + yOffset;
var rightBlockPad = margPile + bordPile + padPile + margBlock + bordBlock + 2 * padBlock + blockWidth + xOffset;
var bottomBlockPad = margPile + bordPile + padPile + margBlock + bordBlock + 2 * padBlock + blockHeight + yOffset;
VerifyRect(drawActions, ref position, leftBlockPad, topBlockPad, rightBlockPad, bottomBlockPad, purple);
// Left border, whole pile
VerifyRect(drawActions, ref position, leftBlockPad - bordBlock, topBlockPad - bordBlock,
leftBlockPad, bottomBlockPad + bordBlock, blue);
// top border, whole pile
VerifyRect(drawActions, ref position, leftBlockPad - bordBlock, topBlockPad - bordBlock,
rightBlockPad + bordBlock, topBlockPad, blue);
// right border, whole pile
VerifyRect(drawActions, ref position, rightBlockPad, topBlockPad - bordBlock,
rightBlockPad + bordBlock, bottomBlockPad + bordBlock, blue);
// bottom border, whole pile
VerifyRect(drawActions, ref position, leftBlockPad - bordBlock, bottomBlockPad,
rightBlockPad + bordBlock, bottomBlockPad + bordBlock, blue);
// The first block itself.
VerifyRect(drawActions, ref position, leftBlockPad + padBlock, topBlockPad + padBlock,
leftBlockPad + padBlock + blockWidth, topBlockPad + padBlock + blockHeight, red);
// The second block itself.
var topBlock2 = bottomBlockPad + bordBlock + margBlock;
VerifyRect(drawActions, ref position, leftPilePad + padPile, topBlock2,
leftPilePad + padPile + blockWidth, topBlock2 + blockHeight, green);
// And that should be all!
Assert.That(position, Is.EqualTo(drawActions.Count));
// A quick check that Relayout puts things in the same places.
drawActions.Clear();
var fixupMap = new Dictionary <Box, Rectangle>();
var div1 = (DivBox)root.FirstBox;
var block1 = div1.FirstBox;
fixupMap[div1] = new Rectangle(0, 0, 10, 10);
fixupMap[block1] = new Rectangle(0, 0, 10, 10);
var oldblock1Left = block1.Left;
var oldblock1bTop = block1.Top;
using (var lcb = new LayoutCallbacks(root))
root.Relayout(layoutInfo, fixupMap, lcb);
Assert.That(drawActions.Count, Is.EqualTo(0));
Assert.That(div1.FirstBox.Left, Is.EqualTo(oldblock1Left));
Assert.That(div1.FirstBox.Top, Is.EqualTo(oldblock1bTop));
}