public void TestModifyArrayCells_setCellType()
{
IWorkbook workbook = _testDataProvider.CreateWorkbook();
ISheet sheet = workbook.CreateSheet();
// Single-cell array formulas behave just like normal cells -
// changing cell type Removes the array formula and associated cached result
ICellRange <ICell> srange =
sheet.SetArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.ValueOf("B5"));
ICell scell = srange.TopLeftCell;
Assert.AreEqual(CellType.Formula, scell.CellType);
Assert.AreEqual(0.0, scell.NumericCellValue, 0);
scell.SetCellType(CellType.String);
Assert.AreEqual(CellType.String, scell.CellType);
scell.SetCellValue("string cell");
Assert.AreEqual("string cell", scell.StringCellValue);
//once you create a multi-cell array formula, you cannot change the type of its cells
ICellRange <ICell> mrange =
sheet.SetArrayFormula("A1:A3*B1:B3", CellRangeAddress.ValueOf("C1:C3"));
foreach (ICell mcell in mrange)
{
try
{
Assert.AreEqual(CellType.Formula, mcell.CellType);
mcell.SetCellType(CellType.Numeric);
Assert.Fail("expected exception");
}
catch (InvalidOperationException e)
{
CellReference ref1 = new CellReference(mcell);
String msg = "Cell " + ref1.FormatAsString() + " is part of a multi-cell array formula. You cannot change part of an array.";
Assert.AreEqual(msg, e.Message);
}
// a failed invocation of Cell.SetCellType leaves the cell
// in the state that it was in prior to the invocation
Assert.AreEqual(CellType.Formula, mcell.CellType);
Assert.IsTrue(mcell.IsPartOfArrayFormulaGroup);
}
workbook.Close();
}
public void TestModifyArrayCells_mergeCellsSingle()
{
IWorkbook workbook = _testDataProvider.CreateWorkbook();
ISheet sheet = workbook.CreateSheet();
Assert.AreEqual(0, sheet.NumMergedRegions);
//Single-cell array formulas behave just like normal cells
ICellRange <ICell> srange =
sheet.SetArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.ValueOf("B5"));
ICell scell = srange.TopLeftCell;
sheet.AddMergedRegion(CellRangeAddress.ValueOf("B5:C6"));
//we are still an array formula
Assert.AreEqual(CellType.Formula, scell.CellType);
Assert.IsTrue(scell.IsPartOfArrayFormulaGroup);
Assert.AreEqual(1, sheet.NumMergedRegions);
workbook.Close();
}
public void TestRemoveArrayFormula()
{
IWorkbook workbook = _testDataProvider.CreateWorkbook();
ISheet sheet = workbook.CreateSheet();
CellRangeAddress range = new CellRangeAddress(3, 5, 2, 2);
Assert.AreEqual("C4:C6", range.FormatAsString());
ICellRange <ICell> cr = sheet.SetArrayFormula("SUM(A1:A3*B1:B3)", range);
Assert.AreEqual(3, cr.Size);
// remove the formula cells in C4:C6
ICellRange <ICell> dcells = sheet.RemoveArrayFormula(cr.TopLeftCell);
// RemoveArrayFormula should return the same cells as SetArrayFormula
Assert.IsTrue(Arrays.Equals(cr.FlattenedCells, dcells.FlattenedCells));
foreach (ICell acell in cr)
{
Assert.IsFalse(acell.IsPartOfArrayFormulaGroup);
Assert.AreEqual(CellType.Blank, acell.CellType);
}
// cells C4:C6 are not included in array formula,
// invocation of sheet.RemoveArrayFormula on any of them throws ArgumentException
foreach (ICell acell in cr)
{
try
{
sheet.RemoveArrayFormula(acell);
Assert.Fail("expected exception");
}
catch (ArgumentException e)
{
String ref1 = new CellReference(acell).FormatAsString();
Assert.AreEqual("Cell " + ref1 + " is not part of an array formula.", e.Message);
}
}
workbook.Close();
}
public void Attack(Unit u, ICellRange range)
{
if (_canAttack && u.Player != Player)
{
List <Cell> cellsInRange = null;
if (UnitType == UnitType.SOLDIER)
{
cellsInRange = range.GetCellsInRange(Position, MaxRange, true);
}
else if (UnitType == UnitType.SNIPER)
{
cellsInRange = range.GetCellsInLineRange(Position);
}
if (cellsInRange.Contains(u.Position))
{
StartCoroutine(Attack(u, 0.6f));
_canAttack = false;
_currentRange = 0;
}
}
}
public void Write(ISpreadsheetWriter spreadsheetWriter)
{
spreadsheetWriter.CurrentPosition = StartPosition;
spreadsheetWriter
.SetFontBold(true)
.SetBorder(BorderStyle.Double, BorderDirection.Bottom, Color.Black)
.Write("Cijfer")
.SetFontBold(false);
int columnsBetweenFirstPoint = ScoresStartColumn - spreadsheetWriter.CurrentPosition.X;
for (int i = 0; i < columnsBetweenFirstPoint; i++)
{
spreadsheetWriter.MoveRight();
spreadsheetWriter.Write(string.Empty);
}
ICellRange maximumScoreCell = spreadsheetWriter.GetCellRange(MaximumScorePosition);
ICellRange standardizationFactorCell = spreadsheetWriter.GetCellRange(StandardizationFactorPosition);
ICellRange minimumGradeCell = spreadsheetWriter.GetCellRange(MinimumGradePosition);
const int maximumPointsColumn = 1;
int numberOfScoreColumns = NumberOfStudents + maximumPointsColumn;
spreadsheetWriter.SetFormat("0.0");
for (int columnIndex = 0; columnIndex < numberOfScoreColumns; columnIndex++)
{
var achievedScorePosition = new Point(spreadsheetWriter.CurrentPosition.X, AchievedScoresRow);
ICellRange achievedScoreCell = spreadsheetWriter.GetCellRange(achievedScorePosition);
spreadsheetWriter
.PlaceLessThanRule(5.5, Color.Red)
.PlaceCustomFormula(SetupGradeFormula(achievedScoreCell,
maximumScoreCell,
standardizationFactorCell,
minimumGradeCell))
.MoveRight();
}
spreadsheetWriter.ResetStyling();
}
public static bool AreEqual(ICellRange cellRange1, ICellRange cellRange2)
{
if (ReferenceEquals(cellRange1, cellRange2))
{
return(true);
}
if (cellRange1 == null && cellRange2 == null)
{
return(true);
}
if (cellRange1 == null || cellRange2 == null)
{
return(false);
}
return(cellRange1.Column == cellRange2.Column &&
cellRange1.Row == cellRange2.Row &&
cellRange1.ColumnSpan == cellRange2.ColumnSpan &&
cellRange1.RowSpan == cellRange2.RowSpan);
}
public void Move(ICellRange range, Cell targetCell)
{
var cellsInRange = range.GetCellsInRange(Position, _currentRange, false);
foreach (var cell in cellsInRange)
{
if (cell.Position.Equals(targetCell.Position))
{
if (targetCell.CanMove() && _isMoving == false)
{
var path = GetComponent <Pathfinder>().FindPath(Position, targetCell);
if (path == null)
{
return;
}
_currentRange -= path.Count;
StartCoroutine(Move(path, 0.6f));
return;
}
}
}
}
internal static bool IntersectsWith(ICellRange cellRange1, ICellRange cellRange2)
{
var columnRange1 = new Interval <int>(cellRange1.Column, cellRange1.Column + cellRange1.ColumnSpan - 1);
var columnRange2 = new Interval <int>(cellRange2.Column, cellRange2.Column + cellRange2.ColumnSpan - 1);
var columnIntersection = Interval.Intersect(columnRange1, columnRange2);
if (columnIntersection.IsEmpty)
{
return(false);
}
var rowRange1 = new Interval <int>(cellRange1.Row, cellRange1.Row + cellRange1.RowSpan - 1);
var rowRange2 = new Interval <int>(cellRange2.Row, cellRange2.Row + cellRange2.RowSpan - 1);
var rowIntersection = Interval.Intersect(rowRange1, rowRange2);
if (rowIntersection.IsEmpty)
{
return(false);
}
return(true);
}
public void TestModifyArrayCells_mergeCells()
{
IWorkbook workbook = _testDataProvider.CreateWorkbook();
ISheet sheet = workbook.CreateSheet();
Assert.AreEqual(0, sheet.NumMergedRegions);
//Single-cell array formulas behave just like normal cells
ICellRange <ICell> srange =
sheet.SetArrayFormula("SUM(A4:A6,B4:B6)", CellRangeAddress.ValueOf("B5"));
ICell scell = srange.TopLeftCell;
sheet.AddMergedRegion(CellRangeAddress.ValueOf("B5:C6"));
//we are still an array formula
Assert.AreEqual(CellType.Formula, scell.CellType);
Assert.IsTrue(scell.IsPartOfArrayFormulaGroup);
Assert.AreEqual(1, sheet.NumMergedRegions);
//we cannot merge cells included in an array formula
ICellRange <ICell> mrange =
sheet.SetArrayFormula("A1:A3*B1:B3", CellRangeAddress.ValueOf("C1:C3"));
CellRangeAddress cra = CellRangeAddress.ValueOf("C1:C3");
try
{
sheet.AddMergedRegion(cra);
Assert.Fail("expected exception");
}
catch (InvalidOperationException e)
{
String msg = "The range " + cra.FormatAsString() + " intersects with a multi-cell array formula. You cannot merge cells of an array.";
Assert.AreEqual(msg, e.Message);
}
//the number of merged regions remains the same
Assert.AreEqual(1, sheet.NumMergedRegions);
}
public static ICellRange Intersect(ICellRange cellRange1, ICellRange cellRange2)
{
var columnRange1 = new Interval <int>(cellRange1.Column, cellRange1.Column + cellRange1.ColumnSpan - 1);
var columnRange2 = new Interval <int>(cellRange2.Column, cellRange2.Column + cellRange2.ColumnSpan - 1);
var columnIntersection = Interval.Intersect(columnRange1, columnRange2);
if (columnIntersection.IsEmpty)
{
return(null);
}
var rowRange1 = new Interval <int>(cellRange1.Row, cellRange1.Row + cellRange1.RowSpan - 1);
var rowRange2 = new Interval <int>(cellRange2.Row, cellRange2.Row + cellRange2.RowSpan - 1);
var rowIntersection = Interval.Intersect(rowRange1, rowRange2);
if (rowIntersection.IsEmpty)
{
return(null);
}
return(CellRange.CreateCellRange(columnIntersection.AsRange(), rowIntersection.AsRange()));
}
public static ICellRange Intersect(this ICellRange cellRange1, ICellRange cellRange2)
{
return(CellRangeUtils.Intersect(cellRange1, cellRange2));
}
internal static int GetTopRow(ICellRange cellRange)
{
return(cellRange.Row);
}
internal static int GetBottomRow(ICellRange cellRange)
{
return(cellRange.Row + cellRange.RowSpan - 1);
}
internal static int GetLeftColumn(ICellRange cellRange)
{
return(cellRange.Column);
}
public static bool Contains(this ICellRange self, ICellRange cellRange)
{
return(CellRangeUtils.Contains(self, cellRange));
}
public static int GetRightColumn(this ICellRange self)
{
return(CellRangeUtils.GetRightColumn(self));
}
public static int GetBottomRow(this ICellRange self)
{
return(CellRangeUtils.GetBottomRow(self));
}
public static bool IntersectsWith(this ICellRange cellRange1, ICellRange cellRange2)
{
return(CellRangeUtils.IntersectsWith(cellRange1, cellRange2));
}
internal static int GetRightColumn(ICellRange cellRange)
{
return(cellRange.Column + cellRange.ColumnSpan - 1);
}