public void PrepareSpreadsheet()
{
//Create item
var dataItem = new TestData { Text = "str", FractionalNumber = 1.0 };
//Create spreadsheet, populate Items collection and build columns
_spreadsheet = Mock.Create<SpreadsheetView>(Behavior.CallOriginal);
_spreadsheet.ItemsSource = new List<TestData> { dataItem };
_spreadsheet.OnApplyTemplate();
//Need one of the columns built
var column = _spreadsheet.Columns.FirstOrDefault(x => x.PropertyName == "Text");
if (column == null)
Assert.Fail();
//Create container but suppress cells creation
var container = new SpreadsheetItemContainer(_spreadsheet);
Mock.NonPublic.Arrange(container, "InitializeCellsWithValues").DoNothing();
container.Item = ItemWrap.BuildNew(dataItem);
//Avoid calling original SetValueBinding and SetEditorParams methods from cell's constructor
Mock.NonPublic.Arrange(typeof(Cell), "SetValueBinding", container.Item);
Mock.NonPublic.Arrange(typeof(Cell), "SetEditorParams");
_cell = column.CreateCell(container) as Cell;
//Mock behavior
_cellInteractionBehaviorMock = Mock.Create<CellInteractionBehavior>(Behavior.CallOriginal);
//Attach behavior to the new control and check that OnAttached method was called
_contentControl = Mock.Create<CellControl>(Behavior.CallOriginal);
_contentControl.Content = _cell;
_contentControl.DataContext = _cell;
_cellInteractionBehaviorMock.Attach(_contentControl);
Mock.NonPublic.Assert(_cellInteractionBehaviorMock, "OnAttached", Occurs.Once());
}
/// <summary>
/// Initializes a new instance of the <see cref="SpreadsheetItemContainer"/> class.
/// </summary>
/// <param name="spreadsheetView">The spreadsheet view.</param>
public SpreadsheetItemContainer(SpreadsheetView spreadsheetView)
{
IsTabStop = false;
_owner = spreadsheetView;
if (_owner != null)
_topLevelSpreadsheet = _owner.GetTopLevelSpreadsheet();
Cells = new CellCollection();
}
public void AssignItemsSourceFirstTest()
{
var spreadsheet = new SpreadsheetView();
var spreadsheetData = new List<TestData>
{
new TestData{Text = "string1", FractionalNumber = 10.0},
new TestData{Text = "string2", FractionalNumber = 20.0},
new TestData{Text = "test text", FractionalNumber = 30.2}
};
var privateAccessor = new PrivateAccessor(spreadsheet);
//By default ItemsSource of SpreadsheetView is null
Assert.IsNull(spreadsheet.ItemsSource);
Mock.NonPublic.Arrange<SpreadsheetView>("OnItemsSourceChanged", ArgExpr.IsAny<DependencyObject>(), ArgExpr.IsAny<DependencyPropertyChangedEventArgs>())
.CallOriginal()
.MustBeCalled();
spreadsheet.ItemsSource = spreadsheetData;
Assert.AreEqual(spreadsheet.ItemsSource, spreadsheetData);
Mock.NonPublic.Assert<SpreadsheetView>("OnItemsSourceChanged", ArgExpr.IsAny<DependencyObject>(), ArgExpr.IsAny<DependencyPropertyChangedEventArgs>());
//FillItemsSource must be called from OnApplyTemplate if it hasn't been invoked yet
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Never(), ArgExpr.IsAny<IEnumerable>());
Assert.IsFalse((bool)privateAccessor.GetField("_templateApplied"));
//We've set SpreadsheetView.ItemsSource but ItemsControl.ItemsSource is still null
var itemsControl = spreadsheet as ItemsControl;
Assert.IsNull(itemsControl.ItemsSource);
//Invoke OnApplyTemplate manually
spreadsheet.OnApplyTemplate();
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Once(), ArgExpr.IsAny<IEnumerable>());
Assert.IsTrue((bool)privateAccessor.GetField("_templateApplied"));
//FillItemsSource calls PopulateColumns
Mock.NonPublic.Assert(spreadsheet, "PopulateColumns", Occurs.Once(), ArgExpr.IsAny<SpreadsheetElementCollection>());
//Now ItemsControl.ItemsSource has value as well
Assert.IsNotNull(itemsControl.ItemsSource);
Assert.AreEqual(itemsControl.ItemsSource.GetType(), typeof(SpreadsheetElementCollection));
//SpreadsheetView.ItemsCollection has only getter which retrieves data from ItemsControl.ItemsSource and casts it to SpreadsheetElementCollection
Assert.AreEqual(itemsControl.ItemsSource, spreadsheet.ItemsCollection);
//Assure that all our elements are there
Assert.AreEqual(((IList)spreadsheet.ItemsSource).Count, spreadsheetData.Count);
Assert.AreEqual(((IList)itemsControl.ItemsSource).Count, spreadsheetData.Count);
}
public void AddNewItemsCommandTests()
{
// arrange
var vm = new SpreadsheetColumnBase();
var view = new SpreadsheetView();
Mock.Arrange(() => view.KeyNavigationByDemand(Key.Insert, true)).MustBeCalled();
Mock.Arrange(() => vm.Owner).Returns(view);
// act
vm.AddNewItemsCommand.Execute(null);
// assert
Mock.Assert(view);
}
public void AssignItemsSourceAfterTemplateAppliedTest()
{
var spreadsheet = new SpreadsheetView();
var spreadsheetData = new List<TestData>
{
new TestData{Text = "string1", FractionalNumber = 10.0},
new TestData{Text = "string2", FractionalNumber = 20.0},
new TestData{Text = "test text", FractionalNumber = 30.2}
};
var privateAccessor = new PrivateAccessor(spreadsheet);
//First we call OnApplyTemplate and only then set value to ItemsSource
spreadsheet.OnApplyTemplate();
//FillItemsSource can not be called if ItemsSource is null
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Never(), ArgExpr.IsAny<IEnumerable>());
Assert.IsTrue((bool)privateAccessor.GetField("_templateApplied"));
//FillItemsSource is invoked from OnItemsSourceChanged
Mock.NonPublic.Arrange(spreadsheet, "FillItemsSource", ArgExpr.IsAny<IEnumerable>()).MustBeCalled();
spreadsheet.ItemsSource = spreadsheetData;
Mock.Assert(spreadsheet);
}
public void AlternateRowsMethodTest()
{
//Create spreadsheet and load data
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
var itemList = new List<TestData>
{
new TestData(),
new TestData()
};
spreadsheet.ItemsSource = itemList;
spreadsheet.OnApplyTemplate();
Mock.NonPublic.Arrange(typeof(SpreadsheetView), "PopulateCells", ArgExpr.IsAny<SpreadsheetItemContainer>(), ArgExpr.IsAny<IWrap>()).DoNothing();
//Get item wrappers
var item1 = spreadsheet.ItemsCollection[0];
var item2 = spreadsheet.ItemsCollection[1];
//Call ItemContainerGenerator overrides
Mock.NonPublic.Arrange(typeof(CellBase), "SetEditorParams").IgnoreInstance().DoNothing();
spreadsheet.ItemContainerStyle = new Style(typeof(SpreadsheetItemContainer));
var container1 = privateAccessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
privateAccessor.CallMethod("PrepareContainerForItemOverride", container1, item1);
var container2 = privateAccessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
privateAccessor.CallMethod("PrepareContainerForItemOverride", container2, item2);
//Mock SetIsAlternate method for all SpreadsheetItemContainer instances
var containerMock = Mock.Create<SpreadsheetItemContainer>(Constructor.Mocked);
Mock.Arrange(() => containerMock.SetIsAlternate()).IgnoreInstance();
//Make spreadsheet invisible
Mock.Arrange(() => spreadsheet.IsVisible).Returns(false);
Mock.Arrange(() => spreadsheet.Items).CallOriginal().OccursNever();
spreadsheet.AlternateRows();
Mock.Assert(spreadsheet);
//Test AlternateRows method in normal conditions
Mock.Arrange(() => spreadsheet.IsVisible).Returns(true);
Mock.Arrange(() => spreadsheet.Items).CallOriginal().MustBeCalled();
spreadsheet.AlternateRows();
var containersDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
Mock.Assert(() => containersDict[item1].SetIsAlternate(), Occurs.Once());
Mock.Assert(() => containersDict[item2].SetIsAlternate(), Occurs.Once());
Mock.Assert(spreadsheet);
}
/// <summary>
/// Draws the vertical lines.
/// </summary>
/// <param name="cell">The cell.</param>
/// <param name="topLevelSpreadSheet">The top level spread sheet.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private static bool DrawVerticalLines(CellBase cell, SpreadsheetView topLevelSpreadSheet)
{
if ((topLevelSpreadSheet.GridLinesVisibility & GridLinesVisibility.Vertical) == GridLinesVisibility.Vertical)
{
var stackCell = cell as StackCell;
if (cell != null && (cell.Owner.Columns.Last() != cell.Column || cell.Owner.ParentSpreadsheet != null) && ((!cell.HasNested || (stackCell != null && (stackCell.ChildSpreadsheet == null || !stackCell.ChildSpreadsheet.Items.Any())))))
{
return true;
}
}
return false;
}
/// <summary>
/// Initializes a new instance of the <see cref="SpreadsheetColumnBase"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
internal SpreadsheetColumnBase(SpreadsheetView owner) : this()
{
SetOwner(owner);
}
public void GetContainerFromItemMethodTest()
{
//Mock spreadsheet
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
//Prepare data
var item = ItemWrap.BuildNew(new TestData());
var container = new SpreadsheetItemContainer(spreadsheet);
var containerHash = container.GetHashCode();
var containersDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
containersDict.Add(item, container);
//Call GetContainerFromItem and assert results
var result = spreadsheet.GetContainerFromItem(item);
Assert.AreEqual(result.GetHashCode(), containerHash);
}
public void OnItemsChangedItemReplaceTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
//Create data
var oldItem = ItemWrap.BuildNew(new TestData());
var newItem = ItemWrap.BuildNew(new TestData());
var oldContainer = new SpreadsheetItemContainer(spreadsheet);
var newContainer = new SpreadsheetItemContainer(spreadsheet);
//Prepare event arguments and container dictionary
var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, newItem, oldItem, 0);
var containerDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
containerDict.Add(oldItem, oldContainer);
//Arrange methods
Mock.Arrange(() => spreadsheet.ItemContainerGenerator.ContainerFromItem(newItem)).Returns(newContainer);
Mock.NonPublic.Arrange(spreadsheet, "BindContainerToItem", newContainer, newItem).CallOriginal();
//Call OnItemsChanged and Assert results
privateAccessor.CallMethod("OnItemsChanged", args);
Assert.AreEqual(containerDict.Count, 1);
Assert.AreEqual(containerDict.First().Key, newItem);
Assert.AreEqual(containerDict[newItem], newContainer);
Mock.NonPublic.Assert(spreadsheet, "BindContainerToItem", Occurs.Once(), newContainer, newItem);
Assert.IsTrue(oldContainer.IsDisposed);
}
public void OnItemsChangedItemAddTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
//Initialize ItemCollection
Mock.NonPublic.Arrange(spreadsheet, "OnItemsChanged", ArgExpr.IsAny<NotifyCollectionChangedEventArgs>()).DoNothing();
spreadsheet.ItemsSource = new List<TestData>();
spreadsheet.OnApplyTemplate();
Assert.IsNotNull(spreadsheet.ItemsCollection);
Mock.Reset();
//Create data item and its wrapper
var dataItem = new TestData {Text = "test", FractionalNumber = 3.5};
var itemWrap = ItemWrap.BuildNew(dataItem);
//Arrabge ManageExpandStates and BindContainerToItem
Mock.Arrange(() => spreadsheet.ManageExpandStates(Arg.IsAny<IDetailColumn>()));
Mock.NonPublic.Arrange(spreadsheet, "BindContainerToItem", ArgExpr.IsAny<SpreadsheetItemContainer>(), ArgExpr.IsAny<IWrap>());
//Make spreadsheet disposed
privateAccessor.SetField("_disposed", true);
spreadsheet.ItemsCollection.Add(itemWrap);
//Check ManageExpandStates and BindContainerToItem invocations when spreadsheet is disposed
Assert.IsTrue((bool)privateAccessor.GetField("_disposed"));
Mock.NonPublic.Assert(spreadsheet, "BindContainerToItem", Occurs.Never(), ArgExpr.IsAny<SpreadsheetItemContainer>(), ArgExpr.IsAny<IWrap>());
Mock.Assert(() => spreadsheet.ManageExpandStates(Arg.IsAny<IDetailColumn>()), Occurs.Never());
//Mock ItemContainerGenerator.ContainerFromItem method and add new item to ItemsCollection
//this invokes OnItemsChanged
privateAccessor.SetField("_disposed", false);
var container = new SpreadsheetItemContainer(spreadsheet);
Mock.Arrange(() => spreadsheet.ItemContainerGenerator.ContainerFromItem(Arg.IsAny<object>())).Returns(container);
Mock.Arrange(() => spreadsheet.ParentColumn).Returns(Mock.Create<IDetailColumn>());
spreadsheet.ItemsCollection.Add(itemWrap);
//Check ManageExpandStates and BindContainerToItem invocations when spreadsheet is not disposed
Assert.IsFalse((bool)privateAccessor.GetField("_disposed"));
Mock.NonPublic.Assert(spreadsheet, "BindContainerToItem", Occurs.Once(), container, itemWrap);
Mock.Assert(() => spreadsheet.ManageExpandStates(Arg.IsAny<IDetailColumn>()), Occurs.Once());
}
/// <summary>
/// Unselects the specified cell.
/// </summary>
/// <param name="cell">The cell.</param>
/// <param name="caller">The caller.</param>
public void Unselect(CellBase cell, SpreadsheetView caller = null)
{
foreach (var child in _childSpreadsheets.Where(x => x.IsVisible))
{
if (child != caller)
child.Unselect(cell, caller);
}
foreach (var item in Items)
{
var container = GetContainerFromItem((IWrap) item);
if (container != null)
container.Unselect(cell);
}
}
/// <summary>
/// Moves the selection from deleted cell.
/// </summary>
/// <param name="spreadsheet">The spreadsheet.</param>
/// <param name="column">The column.</param>
/// <param name="itemIndex">Index of the item.</param>
private void MoveSelectionFromDeletedCell(SpreadsheetView spreadsheet, IColumn column, int itemIndex)
{
if (spreadsheet == null)
return;
if (spreadsheet.Items.Count == 0)
{
if (spreadsheet.ParentCell != null)
spreadsheet.ParentCell.ProcessSelectionCommand(new NavigationInfo());
}
else
{
SpreadsheetItemContainer itemContainer;
if (itemIndex < spreadsheet.Items.Count)
itemContainer = GetContainerFromItem(spreadsheet.Items[itemIndex] as IWrap);
else
itemContainer = GetContainerFromItem(spreadsheet.Items.Last() as IWrap);
if (itemContainer != null && column != null)
{
itemContainer.SelectByColumn(column, new NavigationInfo { SelectParents = column.IsParent });
}
}
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="isDisposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool isDisposing)
{
if (isDisposing)
{
CellSelectionInspector.CellsSelectedChain.Remove(this);
_columnPresenter = null;
_owner = null;
ParentColumn = null;
PreviousColumn = null;
ClearValue(ForegroundProperty);
ClearValue(BackgroundProperty);
ClearValue(StyleProperty);
WidthChanged = null;
PresenterChanged = null;
PropertyChanged = null;
}
IsDisposed = true;
}
/// <summary>
/// Sets the owner.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="forceSetOwner">if set to <c>true</c> [force set owner].</param>
public void SetOwner(SpreadsheetView owner, bool forceSetOwner = false)
{
var oldOwner = _owner;
if (_owner == null || _owner.IsDisposed || forceSetOwner)
{
_owner = owner;
OnPropertyChanged("Owner");
if (owner != null)
ParentColumn = owner.ParentColumn as SpreadsheetColumnBase;
SetInheritanceLevel();
OnOwnerChanged(oldOwner, owner);
}
else
{
if (owner != null && ColumnPanelLoaded)
owner.ColumnPanelLoaded = true;
}
if(forceSetOwner && oldOwner != null)
oldOwner.Dispose();
}
/// <summary>
/// Called when [owner changed].
/// </summary>
/// <param name="oldOwner">The old owner.</param>
/// <param name="newOwner">The new owner.</param>
protected void OnOwnerChanged(SpreadsheetView oldOwner, SpreadsheetView newOwner)
{
if (OwnerChanged != null)
OwnerChanged(this, new ColumnOwnerChangedEventArgs(oldOwner, newOwner));
}
public void CheckPropertiesInitialValuesTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
Assert.IsNotNull(privateAccessor.GetField("_sharedColumns"));
Assert.IsNotNull(privateAccessor.GetField("_containersDict"));
Assert.IsFalse((bool)privateAccessor.GetField("_loaded"));
Assert.IsFalse((bool)privateAccessor.GetField("_templateApplied"));
Assert.IsFalse(spreadsheet.IsDisposed);
Assert.IsFalse(spreadsheet.HasNested);
Assert.IsTrue(spreadsheet.IsTopLevel);
Assert.AreEqual(spreadsheet.FirstRowIndex, 1);
Assert.IsFalse(spreadsheet.HasSelection);
Assert.IsNull(spreadsheet.ParentColumn);
Assert.IsNull(spreadsheet.GlobalDataContext);
Assert.IsNotNull(spreadsheet.Columns);
Assert.IsFalse(spreadsheet.Columns.Any());
Assert.IsNull(spreadsheet.ItemsSource);
Assert.IsTrue(spreadsheet.AutoGenerateColumns);
Assert.IsNull(spreadsheet.ParentSpreadsheet);
Assert.IsNull(spreadsheet.CustomDataContextInitializer);
Assert.IsNull(spreadsheet.ParentCell);
Assert.IsFalse(spreadsheet.IsNested);
Assert.IsTrue(spreadsheet.IsVisible);
Assert.IsNull(spreadsheet.ItemContainerStyle);
Assert.IsTrue(spreadsheet.ShowColumnHeader);
Assert.IsNull(spreadsheet.SelectedHeaderStyle);
Assert.IsNull(spreadsheet.AlternateRowStyle);
Assert.AreEqual(((SolidColorBrush)spreadsheet.AlternateRowBackground).Color, Colors.Yellow);
Assert.AreEqual(spreadsheet.AlternateStyle, AlternateStyles.None);
Assert.AreEqual(((SolidColorBrush)spreadsheet.ColumnHeaderBackground).Color, Color.FromArgb(0xFF, 0x25, 0xA0, 0xDC));
Assert.AreEqual(((SolidColorBrush)spreadsheet.ColumnSelectionBackground).Color, Color.FromArgb(0xFF, 0x2F, 0xD3, 0xFF));
Assert.AreEqual(spreadsheet.GridLinesVisibility, GridLinesVisibility.Both);
Assert.AreEqual(spreadsheet.RowIndicatorVisibility, Visibility.Visible);
Assert.IsNull(spreadsheet.SelectedRowIndicatorStyle);
}
/// <summary>
/// Initializes a new instance of the <see cref="SpreadsheetDetailColumn"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
public SpreadsheetDetailColumn(SpreadsheetView owner) : base(owner)
{
IsToggledManually = false;
}
public void KeyNavigationByDemandMethodTest()
{
var spreadsheet = new SpreadsheetView();
//Move right
Mock.Arrange(() => spreadsheet.MoveRight()).DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Right);
Mock.Assert(() => spreadsheet.MoveRight());
//Move left
Mock.Arrange(() => spreadsheet.MoveLeft()).DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Left);
Mock.Assert(() => spreadsheet.MoveLeft());
//Move up
Mock.Arrange(() => spreadsheet.MoveUp()).DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Up);
Mock.Assert(() => spreadsheet.MoveUp());
//Move Down
Mock.Arrange(() => spreadsheet.MoveDown()).DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Down);
Mock.Assert(() => spreadsheet.MoveDown());
//Start Editing
Mock.NonPublic.Arrange(spreadsheet, "StartEditing").DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Enter);
Mock.NonPublic.Assert(spreadsheet, "StartEditing");
//Insert multiple records (there are cells in edit mode)
Mock.Arrange(() => Keyboard.Modifiers).Returns(ModifierKeys.Shift);
Mock.Arrange(() => spreadsheet.GetEditedCells()).Returns(new CellBase[1]);
Mock.Arrange(() => spreadsheet.InsertMultipleRecords()).DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Insert, true);
Mock.Assert(() => spreadsheet.InsertMultipleRecords(), Occurs.Never());
//Insert multiple records (there are no cells in edit mode)
Mock.Arrange(() => spreadsheet.GetEditedCells()).Returns(new CellBase[0]);
spreadsheet.KeyNavigationByDemand(Key.Insert, true);
Mock.Assert(() => spreadsheet.InsertMultipleRecords(), Occurs.Once());
//Insert new (there are cells in edit mode)
Mock.Arrange(() => spreadsheet.GetEditedCells()).Returns(new CellBase[1]);
Mock.Arrange(() => Keyboard.Modifiers).Returns(ModifierKeys.None);
Mock.Arrange(() => spreadsheet.InsertRecord()).DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Insert);
Mock.Assert(() => spreadsheet.InsertRecord(), Occurs.Never());
//Insert new (there are no cells in edit mode)
Mock.Arrange(() => spreadsheet.GetEditedCells()).Returns(new CellBase[0]);
Mock.Arrange(() => Keyboard.Modifiers).Returns(ModifierKeys.None);
Mock.Arrange(() => spreadsheet.InsertRecord()).DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Insert);
Mock.Assert(() => spreadsheet.InsertRecord(), Occurs.Once());
//Delete record (there are cells in edit mode)
Mock.Arrange(() => spreadsheet.GetEditedCells()).Returns(new CellBase[1]);
Mock.Arrange(() => Keyboard.Modifiers).Returns(ModifierKeys.Shift);
Mock.Arrange(() => spreadsheet.DeleteRecord()).DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Delete, true);
Mock.Assert(() => spreadsheet.DeleteRecord(), Occurs.Never());
//Delete record (there are no cells in edit mode)
Mock.Arrange(() => spreadsheet.GetEditedCells()).Returns(new CellBase[0]);
Mock.Arrange(() => Keyboard.Modifiers).Returns(ModifierKeys.Shift);
Mock.Arrange(() => spreadsheet.DeleteRecord()).DoNothing();
spreadsheet.KeyNavigationByDemand(Key.Delete, true);
Mock.Assert(() => spreadsheet.DeleteRecord(), Occurs.Once());
//Delete values from selected cells (there are cells in edit mode)
var cell1 = Mock.Create<Cell>(Constructor.Mocked);
var cell2 = Mock.Create<StackCell>(Constructor.Mocked);
Mock.Arrange(() => spreadsheet.GetSelectedCells()).Returns(new CellBase[] {cell1, cell2});
Mock.Arrange(() => spreadsheet.GetEditedCells()).Returns(new CellBase[1]);
Mock.Arrange(() => Keyboard.Modifiers).Returns(ModifierKeys.None);
spreadsheet.KeyNavigationByDemand(Key.Delete);
Mock.Assert(() => cell1.ClearValue(), Occurs.Never());
Mock.Assert(() => cell2.ClearValue(), Occurs.Never());
//Delete values from selected cells (there are no cells in edit mode)
Mock.Arrange(() => spreadsheet.GetEditedCells()).Returns(new CellBase[0]);
spreadsheet.KeyNavigationByDemand(Key.Delete);
Mock.Assert(() => cell1.ClearValue(), Occurs.Once());
Mock.Assert(() => cell2.ClearValue(), Occurs.Once());
}
/// <summary>
/// Initializes a new instance of the <see cref="ColumnOwnerChangedEventArgs"/> class.
/// </summary>
/// <param name="oldValue">The old value.</param>
/// <param name="newValue">The new value.</param>
public ColumnOwnerChangedEventArgs(SpreadsheetView oldValue, SpreadsheetView newValue)
{
OldValue = oldValue;
NewValue = newValue;
}
public void OnItemsChangedItemRemoveTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
//Initialize ItemCollection
Mock.NonPublic.Arrange(spreadsheet, "OnItemsChanged", ArgExpr.IsAny<NotifyCollectionChangedEventArgs>()).DoNothing();
var list = new List<TestData>
{
new TestData {Text = "fff", FractionalNumber = 0},
new TestData {Text = "item", FractionalNumber = 55},
new TestData {Text = "last item", FractionalNumber = -5}
};
spreadsheet.ItemsSource = list;
spreadsheet.OnApplyTemplate();
Assert.IsNotNull(spreadsheet.ItemsCollection);
Mock.Reset();
var item1 = spreadsheet.ItemsCollection[0];
var item2 = spreadsheet.ItemsCollection[1];
var item3 = spreadsheet.ItemsCollection[2];
//Bind item1 to container
var container = new SpreadsheetItemContainer(spreadsheet);
Mock.NonPublic.Arrange(container, "InitializeCellsWithValues");
privateAccessor.CallMethod("BindContainerToItem", container, item1);
privateAccessor.CallMethod("BindContainerToItem", container, item3);
//Assert dictionary with containers
var containerDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
Assert.IsNotNull(containerDict);
Assert.AreEqual(containerDict.Count, 2);
containerDict.Add(item2, null);
Assert.AreEqual(containerDict.Count, 3);
//Remove second item from collection (when container is null)
Mock.Arrange(() => containerDict.Remove(item2)).CallOriginal();
spreadsheet.ItemsCollection.Remove(item2);
Mock.Assert(() => containerDict.Remove(item2), Occurs.Once());
Assert.AreEqual(containerDict.Count, 2);
//Remove first item from collection (when container is disposed)
Mock.Arrange(() => container.IsDisposed).Returns(true);
spreadsheet.ItemsCollection.Remove(item1);
Mock.Assert(() => containerDict.Remove(item1), Occurs.Once());
Assert.AreEqual(containerDict.Count, 1);
//Remove item and dispose container
Mock.Arrange(() => container.IsDisposed).Returns(false);
spreadsheet.ItemsCollection.Remove(item3);
Mock.Assert(() => containerDict.Remove(item3), Occurs.Exactly(2));
Assert.AreEqual(containerDict.Count, 0);
Mock.Reset();
Assert.IsTrue(container.IsDisposed);
}
public void GetEditedCellsMethodTest()
{
//Mock spreadsheet
var spreadsheetMock = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheetMock);
//Load data
Mock.NonPublic.Arrange(typeof(CellBase), "SetEditorParams").IgnoreInstance().DoNothing();
spreadsheetMock.ItemsSource = new List<TestData> { new TestData { Text = "text 1" }, new TestData { Text = "another text" } };
spreadsheetMock.OnApplyTemplate();
var item1 = spreadsheetMock.ItemsCollection[0];
var item2 = spreadsheetMock.ItemsCollection[1];
//Call ItemContainerGenerator overrides
var container = privateAccessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
Assert.IsNotNull(container);
spreadsheetMock.ItemContainerStyle = new Style(typeof(SpreadsheetItemContainer));
privateAccessor.CallMethod("PrepareContainerForItemOverride", container, item1);
privateAccessor.CallMethod("PrepareContainerForItemOverride", (SpreadsheetItemContainer)null, item2);
//Assert _containersDict field
var containersDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
Assert.IsNotNull(containersDict);
Assert.AreEqual(containersDict.Count, 2);
Assert.IsTrue(containersDict.ContainsKey(item1));
Assert.AreEqual(containersDict[item1], container);
Assert.IsTrue(containersDict.ContainsKey(item2));
Assert.IsNull(containersDict[item2]);
//Assert cells
Assert.IsNotNull(container.Cells);
Assert.AreEqual(container.Cells.Count, 3);
//Assert GetEditedCells call with only container from one of two elements and with no child spreadsheets
var cell = container.Cells[1];
Mock.Arrange(() => cell.IsEditMode).Returns(true);
var editedCells = spreadsheetMock.GetEditedCells();
Assert.AreEqual(editedCells.Count(), 1);
Assert.AreEqual(editedCells[0], container.Cells[1]);
//Add child spreadsheet
var childSpreadsheet = new SpreadsheetView();
var accessor = new PrivateAccessor(childSpreadsheet);
childSpreadsheet.ItemsSource = new List<TestData> { new TestData { Text = "child item 1" }, new TestData { Text = "child item 2" } };
childSpreadsheet.OnApplyTemplate();
var item3 = childSpreadsheet.ItemsCollection[0];
var item4 = childSpreadsheet.ItemsCollection[1];
var childcontainer1 = accessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
var childcontainer2 = accessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
childSpreadsheet.ItemContainerStyle = new Style(typeof(SpreadsheetItemContainer));
accessor.CallMethod("PrepareContainerForItemOverride", childcontainer1, item3);
accessor.CallMethod("PrepareContainerForItemOverride", childcontainer2, item4);
var cell2 = childcontainer1.Cells[1];
Mock.Arrange(() => cell2.IsEditMode).Returns(true);
var cell3 = childcontainer2.Cells[2];
Mock.Arrange(() => cell3.IsEditMode).Returns(true);
((List<SpreadsheetView>)privateAccessor.GetField("_childSpreadsheets")).Add(childSpreadsheet);
//Assert GetEditedCells call involving invisible child spreadsheet
Mock.Arrange(() => childSpreadsheet.IsVisible).Returns(false);
editedCells = spreadsheetMock.GetEditedCells();
Assert.AreEqual(editedCells.Count(), 1);
Assert.AreEqual(editedCells[0], container.Cells[1]);
//Assert GetEditedCells call involving visible child spreadsheet
Mock.Arrange(() => childSpreadsheet.IsVisible).Returns(true);
editedCells = spreadsheetMock.GetEditedCells();
Assert.AreEqual(editedCells.Count(), 3);
Assert.AreEqual(editedCells[0], childcontainer1.Cells[1]);
Assert.AreEqual(editedCells[1], childcontainer2.Cells[2]);
Assert.AreEqual(editedCells[2], container.Cells[1]);
}
public void OnItemsChangedItemResetTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
var container = new SpreadsheetItemContainer(spreadsheet);
//Arrange ContainerFromItem and initialize spreadsheet ItemsSource collection
Mock.Arrange(() => spreadsheet.ItemContainerGenerator.ContainerFromItem(Arg.IsAny<IWrap>())).Returns(container);
spreadsheet.ItemsSource = new List<TestData> {new TestData{Text = "data1"}};
spreadsheet.OnApplyTemplate();
var containersDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
Assert.AreEqual(containersDict.Count, 1);
Assert.AreEqual(((TestData)containersDict.First().Key.Data).Text, "data1");
//Re-initialize collection to call OnItemsChanged with Reset action and assert results
Mock.NonPublic.Arrange(spreadsheet, "DisposeContainers").CallOriginal().MustBeCalled();
spreadsheet.ItemsSource = new List<TestData> { new TestData { Text = "data2" } };
Assert.AreEqual(containersDict.Count, 1);
Assert.AreEqual(((TestData)containersDict.First().Key.Data).Text, "data2");
Mock.Assert(spreadsheet);
}
public void UnselectMethodTest()
{
var spreadsheetMock = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheetMock);
//Load data
Mock.NonPublic.Arrange(typeof(CellBase), "SetEditorParams").IgnoreInstance().DoNothing();
spreadsheetMock.ItemsSource = new List<TestData> { new TestData { Text = "text 1" }, new TestData { Text = "another text" } };
spreadsheetMock.OnApplyTemplate();
var item1 = spreadsheetMock.ItemsCollection[0];
var item2 = spreadsheetMock.ItemsCollection[1];
//Call ItemContainerGenerator overrides
var container = privateAccessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
Assert.IsNotNull(container);
spreadsheetMock.ItemContainerStyle = new Style(typeof(SpreadsheetItemContainer));
privateAccessor.CallMethod("PrepareContainerForItemOverride", container, item1);
privateAccessor.CallMethod("PrepareContainerForItemOverride", (SpreadsheetItemContainer)null, item2);
//Unselect cells from local spreadsheet
Mock.Arrange(() => spreadsheetMock.Unselect(Arg.IsAny<CellBase>(), Arg.IsAny<SpreadsheetView>()));
Mock.Arrange(() => container.Unselect(Arg.IsAny<CellBase>())).IgnoreInstance().OccursOnce();
var cell = Mock.Create<CellBase>(Constructor.Mocked, Behavior.Loose);
spreadsheetMock.Unselect(cell);
Mock.Assert(container);
//Create child spreadsheets
var childSpreadsheet1 = Mock.Create<SpreadsheetView>(Constructor.Mocked, Behavior.Loose);
Mock.Arrange(() => childSpreadsheet1.IsVisible).Returns(true);
var childSpreadsheet2 = Mock.Create<SpreadsheetView>(Constructor.Mocked, Behavior.Loose);
Mock.Arrange(() => childSpreadsheet2.IsVisible).Returns(false);
var childSpreadsheet3 = Mock.Create<SpreadsheetView>(Constructor.Mocked, Behavior.Loose);
Mock.Arrange(() => childSpreadsheet3.IsVisible).Returns(true);
//Add child spreadsheets
var childSpreadsheets = privateAccessor.GetField("_childSpreadsheets") as List<SpreadsheetView>;
childSpreadsheets.Add(childSpreadsheet1);
childSpreadsheets.Add(childSpreadsheet2);
childSpreadsheets.Add(childSpreadsheet3);
//Call method with child spreadsheets and with caller (the second argument)
Mock.Arrange(() => spreadsheetMock.Unselect(Arg.IsAny<CellBase>(), Arg.IsAny<SpreadsheetView>())).CallOriginal();
spreadsheetMock.Unselect(cell, childSpreadsheet1);
Mock.Assert(() => childSpreadsheet1.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Never());
Mock.Assert(() => childSpreadsheet2.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Never());
Mock.Assert(() => childSpreadsheet3.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Once());
//Call method with child spreadsheets
Mock.Arrange(() => container.Unselect(Arg.IsAny<CellBase>())).IgnoreInstance().Occurs(2);
spreadsheetMock.Unselect(cell);
Mock.Assert(() => childSpreadsheet1.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Once());
Mock.Assert(() => childSpreadsheet2.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Never());
Mock.Assert(() => childSpreadsheet3.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Exactly(2));
}
/// <summary>
/// Initializes a new instance of the <see cref="SpreadsheetColumnBase" /> class.
/// </summary>
/// <param name="owner">The owner.</param>
public SpreadsheetStackColumn(SpreadsheetView owner) : base(owner)
{
InitializeDefaultConstructor();
}
/// <summary>
/// Initializes a new instance of the <see cref="SpreadsheetColumn"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
internal SpreadsheetColumn(SpreadsheetView owner) : base(owner)
{
}
public void GetTopLevelSpreadsheetMethodTest()
{
//Return spreadsheet if spreadsheet.ParentSpreadsheet is null
var spreadsheet = new SpreadsheetView();
var topLevelSpreadsheet = spreadsheet.GetTopLevelSpreadsheet();
Assert.AreEqual(topLevelSpreadsheet, spreadsheet);
//Return parentSpreadsheet if spreadsheet.ParentSpreadsheet equals parentSpreadsheet
var parentSpreadsheet = new SpreadsheetView();
spreadsheet.ParentSpreadsheet = parentSpreadsheet;
topLevelSpreadsheet = spreadsheet.GetTopLevelSpreadsheet();
Assert.AreEqual(topLevelSpreadsheet, parentSpreadsheet);
}
/// <summary>
/// Gets the attached behavior.
/// </summary>
/// <param name="gridview">The gridview.</param>
/// <returns>SpreadsheetViewDragDropBehavior.</returns>
private static SpreadsheetViewDragDropBehavior GetAttachedBehavior(SpreadsheetView gridview)
{
if (gridview == null) return null;
if (!Instances.ContainsKey(gridview))
{
Instances[gridview] = new SpreadsheetViewDragDropBehavior {AssociatedObject = gridview};
}
return Instances[gridview];
}
public static void ArrangeColumns(SpreadsheetView spreadsheet)
{
if (spreadsheet == null)
return;
var columns = new List<IColumn>();
Action<SpreadsheetColumnCollection, List<IColumn>> addColumns = null;
addColumns = (collection, list) =>
{
if (collection == null)
return;
foreach (var column in collection)
{
var stackColumn = column as IStackColumn;
if (stackColumn != null)
//if (column.IsParent)
//if (stackColumn is IDetailColumn && stackColumn.SubColumns.Count == 0)
// list.Add(stackColumn);
//else
{
var columnPresenter = column.ColumnPresenter as StackColumnHeader;
if (columnPresenter != null)
{
if (!columnPresenter.ShowSubColumns)
list.Add(column);
else
addColumns(stackColumn.SubColumns, list);
}
else
addColumns(stackColumn.SubColumns, list);
}
else
list.Add(column);
}
};
addColumns(spreadsheet.Columns, columns);
if (columns.Count == 0)
return;
foreach (IColumn column in columns)
{
if (column.ColumnPresenter != null)
{
if (!column.WidthBeforeArrangement.HasValue)
column.WidthBeforeArrangement = column.ColumnPresenter.DesiredSize.Width;
else if (!double.IsNaN(column.Width))
column.WidthBeforeArrangement = ((column.WidthBeforeArrangement + column.Width) / 2);
}
}
var columnPresenterList = columns.Where(x => x.ColumnPresenter != null).Select(x => x.ColumnPresenter).ToList();
var spreadSheetWidth = spreadsheet.CalculateSpreadsheetWidth();
var totalDesiredWidth = columnPresenterList.Sum(x =>
{
var sourceColumn = x.DataContext as IColumn;
return sourceColumn != null && sourceColumn.WidthBeforeArrangement.HasValue
? Math.Min(sourceColumn.WidthBeforeArrangement.Value, x.DesiredSize.Width)
: x.DesiredSize.Width;
});
var totalAvailableWidth = spreadSheetWidth;
if (spreadsheet.ParentSpreadsheet == null)
{
var rowIndicatorColumns = columns.Where(x => x.IsRowIndicator);
if (rowIndicatorColumns.Any())
{
columnPresenterList.RemoveAll(x => ((IColumn)x.DataContext).IsRowIndicator);
var rowIndicatorColumnsWidth = rowIndicatorColumns.Sum(x => x.Width);
totalDesiredWidth = totalDesiredWidth - rowIndicatorColumnsWidth;
totalAvailableWidth = spreadSheetWidth - rowIndicatorColumnsWidth;
}
}
if (totalDesiredWidth > totalAvailableWidth)
{
var midWidth = totalAvailableWidth / columnPresenterList.Count;
var columnDict = new Dictionary<IColumn, WidthRestrictions>();
foreach (var child in columnPresenterList)
{
if (child.DataContext is IColumn)
{
var column = child.DataContext as IColumn;
var defaultRange = new WidthRestrictions(column.MinWidth, column.MaxWidth);
defaultRange.UpdateValue(column.WidthBeforeArrangement.HasValue
? Math.Min(column.WidthBeforeArrangement.Value, child.DesiredSize.Width)
: child.DesiredSize.Width);
columnDict.Add(column, defaultRange);
}
}
var regularColumns = columnDict.Where(x => x.Value.DesiredWidth <= midWidth).ToList();
var wideColumns = columnDict.Where(x => x.Value.DesiredWidth > midWidth).ToList();
var totalMinWidth = columnDict.Select(x => x.Value.DesiredWidth > midWidth ? midWidth : x.Value.DesiredWidth).Sum();
var availableWidthLeft = totalAvailableWidth - totalMinWidth;
var wideColumnsTotalWidth = wideColumns.Sum(x => x.Value.DesiredWidth);
if (availableWidthLeft < wideColumnsTotalWidth)
{
var availableWidth80 = Math.Ceiling(availableWidthLeft * 0.8);
var availableWidth20 = Math.Ceiling(availableWidthLeft * 0.2);
foreach (var col in wideColumns.ToList())
{
var currentValue = columnDict[col.Key].DesiredWidth;
var newPossibleValue = Math.Ceiling(midWidth + ((col.Value.DesiredWidth / wideColumnsTotalWidth) * availableWidth80));
if ((newPossibleValue < 150) && (currentValue > newPossibleValue * 2))
columnDict[col.Key].UpdateValue(newPossibleValue * 2);
else
columnDict[col.Key].UpdateValue(newPossibleValue);
}
var extraWidth = availableWidth20 / regularColumns.Count;
foreach (var col in regularColumns.ToList())
{
columnDict[col.Key].UpdateValue(columnDict[col.Key].DesiredWidth + extraWidth);
}
}
else if (availableWidthLeft > wideColumnsTotalWidth)
{
var extraWidth = (availableWidthLeft - wideColumnsTotalWidth) / columnDict.Count;
foreach (var col in regularColumns.ToList())
{
columnDict[col.Key].UpdateValue(columnDict[col.Key].DesiredWidth + extraWidth);
}
foreach (var col in wideColumns.ToList())
{
columnDict[col.Key].UpdateValue(midWidth + ((col.Value.DesiredWidth / wideColumnsTotalWidth) * availableWidthLeft) + extraWidth);
}
}
foreach (var item in columnDict)
{
if (item.Key.ColumnPanelLoaded)
item.Key.Width = Math.Ceiling(item.Value.DesiredWidth);//Math.Round(item.Value.DesiredWidth, 0);
}
foreach (var col in spreadsheet.Columns.Where(x => x.IsParent))
{
col.UpdateAutoSize();
}
var roundingInaccuracy = spreadSheetWidth - columns.Sum(x => x.Width);
if (wideColumns.Any() && roundingInaccuracy > 0)
{
columnDict.FirstOrDefault(x => x.Key == wideColumns.First().Key).Key.Width += roundingInaccuracy;
}
}
else
{
var extraSpace = (totalAvailableWidth - totalDesiredWidth) / columns.Count(x => !x.IsRowIndicator);
foreach (var column in columns.Where(x => !x.IsRowIndicator))
{
if (column.ColumnPanelLoaded && (double.IsNaN(column.Width) || column.WidthBeforeArrangement.HasValue))
column.Width = Math.Ceiling((column.WidthBeforeArrangement.HasValue
? Math.Min(column.WidthBeforeArrangement.Value, column.ColumnPresenter.DesiredSize.Width)
: column.ColumnPresenter.DesiredSize.Width) + extraSpace);
else
column.Width += extraSpace;
}
}
}
/// <summary>
/// Cleans up.
/// </summary>
protected virtual void CleanUp()
{
UnsubscribeFromDragDropEvents();
if (Instances.ContainsKey(AssociatedObject))
{
var behavior = Instances[AssociatedObject];
Instances.Remove(AssociatedObject);
behavior.AssociatedObject = null;
}
AssociatedObject = null;
}