public void NonIntersectingRegionSet_RemoveRegionTest()
{
var target = new NonIntersectingMergingRegionsSet <int, RectangularRegion <int> >();
var rectangularRegions = this.GetNonIntersectionFlower();
target.Add(rectangularRegions.Item1);
for (int i = 0; i < rectangularRegions.Item2.Count; ++i)
{
target.Add(rectangularRegions.Item2[i]);
}
var targetCount = target.Count;
Assert.IsFalse(target.RemoveRegion(new RectangularRegion <int>(0, 0, 2, 2)));
target.AssertIntegrity();
Assert.IsTrue(target.RemoveRegion(rectangularRegions.Item1));
target.AssertIntegrity();
--targetCount;
Assert.AreEqual(targetCount, target.Count);
for (int i = 0; i < rectangularRegions.Item2.Count; ++i)
{
Assert.IsTrue(target.RemoveRegion(rectangularRegions.Item2[i]));
target.AssertIntegrity();
--targetCount;
Assert.AreEqual(targetCount, target.Count);
}
}
/// <summary>
/// Instancia uma nova instância de objectos do tipo <see cref="HtmlTableWriter"/>.
/// </summary>
/// <param name="indent">Valor que indica se se pretende identar o html.</param>
public HtmlTableWriter(bool indent = false)
: base(indent)
{
this.headerMergingRegions = new NonIntersectingMergingRegionsSet <int, MergingRegion <int> >();
this.bodyMergingRegions = new NonIntersectingMergingRegionsSet <int, MergingRegion <int> >();
this.headerRowAttributesSetter = (i, s) => { };
this.headerCellElement = (i, j, o, e) =>
{
if (o != null)
{
e.InnerText = o.ToString();
}
};
}
/// <summary>
/// Obtém uma matriz de regiões rectangulares que não se intersectam.
/// </summary>
/// <returns>A matriz de regiões.</returns>
private NonIntersectingMergingRegionsSet <int, RectangularRegion <int> > GetMatrixRegion()
{
var result = new NonIntersectingMergingRegionsSet <int, RectangularRegion <int> >();
for (int i = 0; i < 15; i += 4)
{
for (int j = 0; j < 15; j += 4)
{
result.Add(new RectangularRegion <int>(i, j, i + 1, j + 1));
}
}
return(result);
}
public void NonIntersectingMergingRegionSet_AddAndCountTest()
{
var target = new NonIntersectingMergingRegionsSet <int, RectangularRegion <int> >();
var rectangularRegions = this.GetNonIntersectionFlower();
target.Add(rectangularRegions.Item1);
target.AssertIntegrity();
for (int i = 0; i < rectangularRegions.Item2.Count; ++i)
{
target.Add(rectangularRegions.Item2[i]);
target.AssertIntegrity();
}
Assert.AreEqual(rectangularRegions.Item2.Count + 1, target.Count);
}
public void NonIntersectiongRegionSet_TryAddCrossBorderIntersectingRegionTest()
{
var target = new NonIntersectingMergingRegionsSet <int, RectangularRegion <int> >();
var rectangularRegions = this.GetNonIntersectionFlower();
target.Add(rectangularRegions.Item1);
for (int i = 0; i < rectangularRegions.Item2.Count; ++i)
{
target.Add(rectangularRegions.Item2[i]);
}
// Tenta adicionar uma região que se intersecte com as anteriores
var addingRegion = new RectangularRegion <int>(2, 2, 3, 3);
target.Add(addingRegion);
}
public void NonIntersectingRegionSet_GetMergingRegionForCellTest()
{
var target = new NonIntersectingMergingRegionsSet <int, RectangularRegion <int> >();
var rectangularRegions = this.GetNonIntersectionFlower();
target.Add(rectangularRegions.Item1);
for (int i = 0; i < rectangularRegions.Item2.Count; ++i)
{
target.Add(rectangularRegions.Item2[i]);
}
var actual = target.GetMergingRegionForCell(0, 0);
Assert.IsNull(actual);
actual = target.GetMergingRegionForCell(12, 12);
Assert.IsNull(actual);
for (int i = 3; i < 9; ++i)
{
for (int j = 3; j < 9; ++j)
{
actual = target.GetMergingRegionForCell(i, j);
Assert.AreEqual(rectangularRegions.Item1, actual);
}
}
for (int i = 0; i < rectangularRegions.Item2.Count; ++i)
{
var currentRectangularRegion = rectangularRegions.Item2[i];
for (int j = currentRectangularRegion.TopLeftX; j <= currentRectangularRegion.BottomRightX; ++j)
{
for (int k = currentRectangularRegion.TopLeftY; k < currentRectangularRegion.BottomRightY; ++k)
{
actual = target.GetMergingRegionForCell(j, k);
Assert.AreEqual(currentRectangularRegion, actual);
}
}
}
}
/// <summary>
/// Imprime um item tabular para o elemento da tabela.
/// </summary>
/// <typeparam name="R">O tipo dos objectos que constituem as linhas do item tabular.</typeparam>
/// <typeparam name="L">O tipo dos objectos que constituem as células do item tabular.</typeparam>
/// <param name="cellElementName">O nome do elemento da célula.</param>
/// <param name="element">O elemento da tabela que irá conter as linhas.</param>
/// <param name="columnsNumber">O número de colunas esperado.</param>
/// <param name="tabularItem">O item tabular.</param>
/// <param name="mergingRegions">O conjunto de regiões de células fundidas.</param>
/// <param name="attributessSetter">A função responsável pela adição de atributos.</param>
/// <param name="elementsSetter">A função responsável pelo processamento de elementos.</param>
private void PrintTabularItem <R, L>(
string cellElementName,
XmlElement element,
int columnsNumber,
IGeneralTabularItem <R> tabularItem,
NonIntersectingMergingRegionsSet <int, MergingRegion <int> > mergingRegions,
Action <int, AttributeSetter> attributessSetter,
Action <int, int, object, ElementSetter> elementsSetter)
where R : IGeneralTabularRow <L>
where L : IGeneralTabularCell
{
var attributeSetter = new AttributeSetter();
var validatedCellElementSetter = new ValidatedCellElementSetter();
var linesNumber = tabularItem.LastRowNumber + 1;
var linePointer = 0;
foreach (var tabularLine in tabularItem)
{
var currentLine = tabularLine.RowNumber;
for (; linePointer < currentLine; ++linePointer)
{
var rowElement = element.OwnerDocument.CreateElement("tr");
attributeSetter.CurrentElement = rowElement;
attributessSetter.Invoke(
linePointer,
attributeSetter);
this.AppendEmptyCells(
cellElementName,
rowElement,
linePointer,
columnsNumber,
linesNumber,
columnsNumber,
validatedCellElementSetter,
mergingRegions,
elementsSetter);
element.AppendChild(rowElement);
}
var lineElement = element.OwnerDocument.CreateElement("tr");
attributeSetter.CurrentElement = lineElement;
attributessSetter.Invoke(
linePointer,
attributeSetter);
var currentCellNumber = 0;
foreach (var tabularCell in tabularLine)
{
if (currentCellNumber <= tabularCell.ColumnNumber)
{
var emptyCellsCount = tabularCell.ColumnNumber - currentCellNumber;
this.AppendEmptyCells(
cellElementName,
lineElement,
linePointer,
emptyCellsCount,
linesNumber,
columnsNumber,
validatedCellElementSetter,
mergingRegions,
elementsSetter);
var mergingRegion = mergingRegions.GetMergingRegionForCell(
tabularCell.ColumnNumber,
currentLine);
if (mergingRegion == null)
{
var tableCellElement = lineElement.OwnerDocument.CreateElement(cellElementName);
validatedCellElementSetter.CurrentElement = tableCellElement;
lineElement.AppendChild(tableCellElement);
elementsSetter.Invoke(
currentLine,
tabularCell.ColumnNumber,
tabularCell.GetCellValue <object>(),
validatedCellElementSetter);
lineElement.AppendChild(tableCellElement);
currentCellNumber = tabularCell.ColumnNumber + 1;
}
else if (mergingRegion.TopLeftX == tabularCell.ColumnNumber)
{
var colDifference = mergingRegion.BottomRightX - mergingRegion.TopLeftX;
if (mergingRegion.TopLeftY == currentLine)
{
var tableCellElement = lineElement.OwnerDocument.CreateElement(cellElementName);
validatedCellElementSetter.CurrentElement = tableCellElement;
lineElement.AppendChild(tableCellElement);
elementsSetter.Invoke(
currentLine,
tabularCell.ColumnNumber,
tabularCell.GetCellValue <object>(),
validatedCellElementSetter);
if (colDifference > 0)
{
var colSpan = Math.Min(
colDifference + 1,
columnsNumber - tabularCell.ColumnNumber);
if (colSpan > 1)
{
tableCellElement.SetAttribute("colspan", colSpan.ToString());
}
}
var rowDifference = mergingRegion.BottomRightY - mergingRegion.TopLeftY;
if (rowDifference > 0)
{
var rowSpan = Math.Min(
rowDifference + 1,
linesNumber - currentLine);
if (rowSpan > 1)
{
tableCellElement.SetAttribute("rowspan", rowSpan.ToString());
}
}
}
currentCellNumber = tabularCell.ColumnNumber + colDifference + 1;
}
}
}
var finalEmptyCellsCount = columnsNumber - currentCellNumber;
this.AppendEmptyCells(
cellElementName,
lineElement,
linePointer,
finalEmptyCellsCount,
linesNumber,
columnsNumber,
validatedCellElementSetter,
mergingRegions,
elementsSetter);
element.AppendChild(lineElement);
++linePointer;
}
// Inserção das restantes linhas vazias
for (; linePointer < linesNumber; ++linePointer)
{
var rowElement = element.OwnerDocument.CreateElement("th");
attributeSetter.CurrentElement = rowElement;
this.headerRowAttributesSetter.Invoke(
linePointer,
attributeSetter);
this.AppendEmptyCells(
cellElementName,
rowElement,
linePointer,
columnsNumber,
linesNumber,
columnsNumber,
validatedCellElementSetter,
mergingRegions,
elementsSetter);
}
}
/// <summary>
/// Adenda células do vazias a uma linha do cabeçalho.
/// </summary>
/// <param name="cellElementName">O nome da célula.</param>
/// <param name="lineElement">A linha à qual serão adicionadas células vazias.</param>
/// <param name="currentLine">O número da linha de inserção.</param>
/// <param name="count">O número de elementos a inserir.</param>
/// <param name="linesNumber">O número de linhas na tabela.</param>
/// <param name="columnsNumber">O número de colunas.</param>
/// <param name="elementSetter">O objecto responsável pela alteração do elemento.</param>
/// <param name="mergingRegions">As regiões de fusão de células.</param>
/// <param name="elementsSetter">A função responsável pelo processamento dos elementos.</param>
private void AppendEmptyCells(
string cellElementName,
XmlElement lineElement,
int currentLine,
int count,
int linesNumber,
int columnsNumber,
ValidatedCellElementSetter elementSetter,
NonIntersectingMergingRegionsSet <int, MergingRegion <int> > mergingRegions,
Action <int, int, object, ElementSetter> elementsSetter)
{
for (int i = 0; i < count; ++i)
{
var mergingRegion = mergingRegions.GetMergingRegionForCell(
i,
currentLine);
if (mergingRegion == null)
{
var tableCellElement = lineElement.OwnerDocument.CreateElement(cellElementName);
elementSetter.CurrentElement = tableCellElement;
lineElement.AppendChild(tableCellElement);
elementsSetter.Invoke(
currentLine,
i,
null,
elementSetter);
lineElement.AppendChild(tableCellElement);
}
else if (mergingRegion.TopLeftX == i)
{
var colDifference = mergingRegion.BottomRightX - mergingRegion.TopLeftY;
if (mergingRegion.TopLeftY == currentLine)
{
var tableCellElement = lineElement.OwnerDocument.CreateElement(cellElementName);
elementSetter.CurrentElement = tableCellElement;
lineElement.AppendChild(tableCellElement);
elementsSetter.Invoke(
currentLine,
i,
null,
elementSetter);
if (colDifference > 0)
{
var colSpan = Math.Min(
colDifference + 1,
columnsNumber - i);
if (colSpan > 1)
{
tableCellElement.SetAttribute("colspan", colSpan.ToString());
}
}
var rowDifference = mergingRegion.BottomRightY - mergingRegion.TopLeftY;
if (rowDifference > 0)
{
var rowSpan = Math.Min(
rowDifference + 1,
linesNumber - currentLine);
if (rowSpan > 1)
{
tableCellElement.SetAttribute("rowspan", rowSpan.ToString());
}
}
}
i += colDifference;
}
}
}
