private void GridDragDropManager_OnDropped(object sender, GridDroppedEventArgs e)
{
//var manager = (GridDragDropManager)sender;
//var draggingRow = (Student)manager.DraggingRows[0];
//var dataIndex = ((DragableViewModel)DataContext).Students.IndexOf(draggingRow);
//if (draggingRow.Sort != dataIndex)
//{
// //draggingRow.OperationType = 3;
// //draggingRow.Sort = dataIndex;
// TestGrid.SetCellValue(dataIndex, "OperationType", 3);
// TestGrid.SetCellValue(dataIndex, "Sort", dataIndex);
//}
for (var i = 0; i < TestGrid.VisibleRowCount; i++)
{
var rowHandle = TestGrid.GetRowHandleByVisibleIndex(i);
if (TestGrid.IsGroupRowHandle(rowHandle))
{
throw new NotImplementedException();
}
if (int.TryParse(TestGrid.GetCellValue(i, "Sort")?.ToString(), out int oldIndex))
{
if (oldIndex != i)
{
TestGrid.SetCellValue(i, "OperationType", 3);
TestGrid.SetCellValue(i, "Sort", i);
}
}
}
}
public void Init()
{
_query = (new DefaultHttpContext()).Request.Query;
_repo = new TestRepository();
_grid = new TestGrid(_repo.GetAll());
}
void OnDynamicTableViewCallBack(int evt, int index)
{
if (evt == (int)LayoutRule.DYNAMIC_DELEGATE_EVENT.DYNAMIC_GRID_ATINDEX)
{
int rand = index % 3 + 1;
RectTransform trans = DynamicTable.PreDequeueGrid(rand.ToString(), index);
if (trans == null || GridDic == null)
{
return;
}
TestGrid grid = null;
if (!GridDic.TryGetValue(trans, out grid))
{
grid = new TestGrid(trans);
GridDic.Add(trans, grid);
}
if (grid == null)
{
return;
}
string content = m_ChatContentList[index - 1];
grid.SetContent(index, content);
}
else if (evt == (int)LayoutRule.DYNAMIC_DELEGATE_EVENT.DYNAMIC_GRID_RECYCLE)
{
}
}
public void Init()
{
_query = QueryDictionary <StringValues> .Convert((new DefaultHttpContext()).Request.Query);
_repo = new TestRepository();
_grid = new TestGrid(_repo.GetAll());
}
void TestWrappingEdgeEast(TestGrid grid)
{
int x;
int y;
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
x = grid.RowCount - 1;
for (y = 0; y < grid.RowCount; y++)
{
var sourcePosition = new CartesianGridCoordinates {
x = (short)x, y = (short)y
};
var sourceCubeFace = new CartesianGridOnCubeFace {
Value = (byte)faceIndex
};
var sourceCellIndex = CartesianGridOnCubeUtility.CellIndex(sourcePosition, sourceCubeFace, grid.RowCount);
var exitPosition = new CartesianGridCoordinates {
x = (short)(x + 1), y = (short)y
};
var edge = CartesianGridMovement.CubeExitEdge(exitPosition, grid.RowCount);
Assert.AreEqual(edge, 3);
var nextCellIndex = CartesianGridOnCubeUtility.CellIndexEast(sourceCellIndex, grid.RowCount, grid.FaceLocalToLocal);
var nextDirection = CartesianGridOnCubeUtility.NextFaceDirection[(edge * 6) + faceIndex];
var reverseDirection = CartesianGridMovement.ReverseDirection[nextDirection];
var returnCellIndex = CartesianGridOnCubeUtility.CellIndexFromExitEdge(reverseDirection, nextCellIndex, grid.RowCount);
Assert.AreEqual(returnCellIndex, sourceCellIndex);
}
}
}
private bool ValidateFiltering(TestGrid grid, ColumnFilterValue value,
Func <TestModel, bool> filterExpression)
{
var settingsMock = new Mock <IGridSettingsProvider>();
var filterSetting = new Mock <IGridFilterSettings>();
var filterCollection = new DefaultFilterColumnCollection {
value
};
filterSetting.Setup(t => t.FilteredColumns).Returns(filterCollection);
filterSetting.Setup(t => t.IsInitState(_grid.Columns.First())).Returns(false);
settingsMock.Setup(s => s.FilterSettings).Returns(filterSetting.Object);
settingsMock.Setup(s => s.SortSettings).Returns(new QueryStringSortSettings(_query));
settingsMock.Setup(s => s.SearchSettings).Returns(new QueryStringSearchSettings(_query));
grid.Settings = settingsMock.Object;
IEnumerable <TestModel> resultCollection = _grid.GetItemsToDisplay();
if (!resultCollection.Any())
{
Assert.Fail("No items to compare");
}
IEnumerable <TestModel> etalonCollection = _repo.GetAll().Where(filterExpression);
if (!ValidateCollectionsTheSame(resultCollection, etalonCollection))
{
return(false);
}
return(true);
}
private void TableView_OnInitNewRow(object sender, InitNewRowEventArgs e)
{
var newRow = TestGrid.GetRow(e.RowHandle);
var obj = (HotKeyDto)newRow;
obj.Name = "New";
}
public void Init()
{
_grid = new TestGrid(Enumerable.Empty <TestModel>());
var htmlHelper = new Mock <IHtmlHelper>();
_opt = new GridHtmlOptions <TestModel>(htmlHelper.Object, _grid, "_Grid");
}
public void Init()
{
HttpContext.Current = new HttpContext(new HttpRequest("", "http://tempuri.org", ""), new HttpResponse(new StringWriter()));
_grid = new TestGrid(new TestDataQueryable <TestModel>(Enumerable.Empty <TestModel>()));
var viewContextMock = new Mock <ViewContext>();
_opt = new GridHtmlOptions <TestModel>(_grid, viewContextMock.Object, "_Grid");
}
private bool ValidateSorting <T, TNext>(TestGrid grid, Func <TestModel, T> orderExpression,
string columnName,
GridSortDirection direction,
Func <TestModel, TNext> orderExpression2,
string columnName2,
GridSortDirection?direction2)
{
var payload = new ColumnOrderValue(columnName, direction,
grid.Settings.SortSettings.SortValues.Count + 1);
grid.Query.AddParameter(ColumnOrderValue.DefaultSortingQueryParameter, payload.ToString());
grid.Settings = new QueryStringGridSettingsProvider(grid.Query);
IOrderedEnumerable <TestModel> etalonCollection;
switch (direction)
{
case GridSortDirection.Ascending:
etalonCollection = _repo.GetAll().OrderBy(orderExpression);
break;
case GridSortDirection.Descending:
etalonCollection = _repo.GetAll().OrderByDescending(orderExpression);
break;
default:
throw new ArgumentOutOfRangeException("direction");
}
if (orderExpression2 != null && !string.IsNullOrWhiteSpace(columnName2) && direction2.HasValue)
{
payload = new ColumnOrderValue(columnName2, direction2.Value,
grid.Settings.SortSettings.SortValues.Count + 1);
grid.Query.AddParameter(ColumnOrderValue.DefaultSortingQueryParameter, payload.ToString());
grid.Settings = new QueryStringGridSettingsProvider(grid.Query);
switch (direction2.Value)
{
case GridSortDirection.Ascending:
etalonCollection = _repo.GetAll().OrderBy(orderExpression2);
break;
case GridSortDirection.Descending:
etalonCollection = _repo.GetAll().OrderByDescending(orderExpression2);
break;
default:
throw new ArgumentOutOfRangeException("direction");
}
}
IEnumerable <TestModel> resultCollection = grid.GetItemsToDisplay();
if (!ValidateCollectionsTheSame(resultCollection, etalonCollection))
{
return(false);
}
return(true);
}
public void TestSortingIgnoredIfAlreadyAppliedToQueryable()
{
_grid = new TestGrid(_repo.GetAll().OrderBy(x => x.Title));
_grid.Columns.Add(x => x.Title).Sortable(true);
if (ValidateSorting <string, object>(_grid, x => x.Title, "Title", GridSortDirection.Descending, null, null))
{
Assert.Fail("Sort should be ignored because it's already been applied to Queryable");
}
}
public void Init()
{
HttpContext.Current = new HttpContext(
new HttpRequest("", "http://tempuri.org", ""),
new HttpResponse(new StringWriter()));
_repo = new TestRepository();
_grid = new TestGrid(_repo.GetAll());
}
public void MatchingEdgesOddSize()
{
using (var grid = new TestGrid(17))
{
TestWrappingEdgeNorth(grid);
TestWrappingEdgeSouth(grid);
TestWrappingEdgeWest(grid);
TestWrappingEdgeEast(grid);
}
}
public void Init()
{
var repo = new TestRepository();
var items = repo.GetAll().ToList();
_grid = new TestGrid(items);
_columns = new GridColumnCollection <TestModel>(_grid, new DefaultColumnBuilder <TestModel>(_grid, new GridAnnotationsProvider()), _grid.Settings.SortSettings);
}
public void Init()
{
HttpContext context = new DefaultHttpContext();
_grid = new TestGrid(Enumerable.Empty <TestModel>());
var viewContextMock = new Mock <ViewContext>();
var viewEngine = new MyViewEngine();
_opt = new GridHtmlOptions <TestModel>(_grid, viewContextMock.Object, "_Grid", viewEngine);
}
private bool ValidateSorting <T, TNext>(TestGrid grid, Func <TestModel, T> orderExpression,
string columnName,
GridSortDirection direction,
Func <TestModel, TNext> thenByExpression,
GridSortDirection?thenByDirection)
{
var settingsMock = new Mock <IGridSettingsProvider>();
settingsMock.Setup(s => s.SortSettings.ColumnName).Returns(columnName);
settingsMock.Setup(s => s.SortSettings.Direction).Returns(direction);
settingsMock.Setup(s => s.FilterSettings).Returns(new QueryStringFilterSettings(_query));
settingsMock.Setup(s => s.SearchSettings).Returns(new QueryStringSearchSettings(_query));
grid.Settings = settingsMock.Object;
IEnumerable <TestModel> resultCollection = _grid.GetItemsToDisplay();
IOrderedEnumerable <TestModel> etalonCollection;
switch (direction)
{
case GridSortDirection.Ascending:
etalonCollection = _repo.GetAll().OrderBy(orderExpression);
break;
case GridSortDirection.Descending:
etalonCollection = _repo.GetAll().OrderByDescending(orderExpression);
break;
default:
throw new ArgumentOutOfRangeException("direction");
}
if (thenByExpression != null)
{
switch (thenByDirection)
{
case GridSortDirection.Ascending:
etalonCollection = etalonCollection.ThenBy(thenByExpression);
break;
case GridSortDirection.Descending:
etalonCollection = etalonCollection.ThenByDescending(thenByExpression);
break;
default:
throw new ArgumentOutOfRangeException("thenByDirection");
}
}
if (!ValidateCollectionsTheSame(resultCollection, etalonCollection))
{
return(false);
}
return(true);
}
public void Init()
{
Action <IGridColumnCollection <TestModel> > columns = c =>
{
c.Add(r => r.Id);
};
var repo = new TestRepository();
_grid = new TestGrid((q) => repo.GetAllService(columns, q, false, true), true, columns, Thread.CurrentThread.CurrentCulture);
_columns = new GridColumnCollection <TestModel>(_grid, new DefaultColumnBuilder <TestModel>(_grid, new GridAnnotaionsProvider()), _grid.Settings.SortSettings);
}
public void PathRandomObstacles()
{
using (var grid = new TestGrid(31))
{
int obstacleCount = 32;
var rand = new Unity.Mathematics.Random(0xF545AA3F);
for (int i = 0; i < obstacleCount; i++)
{
var faceIndex = rand.NextInt(0, 6);
var xy = rand.NextInt2(new int2(grid.RowCount, grid.RowCount));
var sourcePosition = new CartesianGridCoordinates {
x = (short)xy.x, y = (short)xy.y
};
var cubeFace = new CartesianGridOnCubeFace {
Value = (byte)faceIndex
};
var cellIndex = CartesianGridOnCubeUtility.CellIndex(sourcePosition, cubeFace, grid.RowCount);
if (rand.NextBool())
{
grid.AddWallWest(cellIndex);
}
else
{
grid.AddWallSouth(cellIndex);
}
}
int testCount = 64;
for (int i = 0; i < testCount; i++)
{
var sourceXY = rand.NextInt2(new int2(grid.RowCount, grid.RowCount));
var sourceFaceIndex = rand.NextInt(0, 6);
var sourceCubeFace = new CartesianGridOnCubeFace {
Value = (byte)sourceFaceIndex
};
var sourcePosition = new CartesianGridCoordinates {
x = (short)sourceXY.x, y = (short)sourceXY.y
};
var targetXY = rand.NextInt2(new int2(grid.RowCount, grid.RowCount));
var targetFaceIndex = rand.NextInt(0, 6);
var targetCubeFace = new CartesianGridOnCubeFace {
Value = (byte)targetFaceIndex
};
var targetPosition = new CartesianGridCoordinates {
x = (short)targetXY.x, y = (short)targetXY.y
};
grid.WalkPathDistance(sourcePosition, sourceCubeFace, targetPosition, targetCubeFace);
}
}
}
private void LimitGrid_SelectionChanged(object sender, EventArgs e)
{
DisableEditors();
TestGrid.ClearSelection();
ResultDef.LimitDefBase Limit;
if (LimitGrid.SelectedRows.Count > 0)
{
string Name = (string)LimitGrid.SelectedRows[0].Cells[LimitName.Index].Value;
m_ResultDef.GetLimitValue(Name, out Limit);
ActivateLimitEditor(Limit);
}
;
}
private bool ValidateSorting <T, TNext>(TestGrid grid, Func <TestModel, T> orderExpression,
string columnName,
GridSortDirection direction,
Func <TestModel, TNext> thenByExpression,
GridSortDirection?thenByDirection)
{
grid.AddQueryParameter(((QueryStringSortSettings)grid.Settings.SortSettings)
.ColumnQueryParameterName, columnName);
grid.AddQueryParameter(((QueryStringSortSettings)grid.Settings.SortSettings)
.DirectionQueryParameterName, direction.ToString("d"));
grid.UpdateGrid().Wait();
IEnumerable <TestModel> resultCollection = grid.GetItemsToDisplay();
IOrderedEnumerable <TestModel> etalonCollection;
switch (direction)
{
case GridSortDirection.Ascending:
etalonCollection = _repo.GetAll().OrderBy(orderExpression);
break;
case GridSortDirection.Descending:
etalonCollection = _repo.GetAll().OrderByDescending(orderExpression);
break;
default:
throw new ArgumentOutOfRangeException("direction");
}
if (thenByExpression != null)
{
switch (thenByDirection)
{
case GridSortDirection.Ascending:
etalonCollection = etalonCollection.ThenBy(thenByExpression);
break;
case GridSortDirection.Descending:
etalonCollection = etalonCollection.ThenByDescending(thenByExpression);
break;
default:
throw new ArgumentOutOfRangeException("thenByDirection");
}
}
if (!ValidateCollectionsTheSame(resultCollection, etalonCollection))
{
return(false);
}
return(true);
}
public void PathOnEmptyGrid()
{
using (var grid = new TestGrid(16))
{
var targetPosition = new CartesianGridCoordinates {
x = 15, y = 15
};
var targetCubeFace = new CartesianGridOnCubeFace {
Value = 0
};
var sourcePosition = new CartesianGridCoordinates {
x = 8, y = 8
};
var sourceCubeFace0 = new CartesianGridOnCubeFace {
Value = 0
};
var sourceCubeFace1 = new CartesianGridOnCubeFace {
Value = 1
};
var sourceCubeFace2 = new CartesianGridOnCubeFace {
Value = 2
};
var sourceCubeFace3 = new CartesianGridOnCubeFace {
Value = 3
};
var sourceCubeFace4 = new CartesianGridOnCubeFace {
Value = 4
};
var sourceCubeFace5 = new CartesianGridOnCubeFace {
Value = 5
};
var dist0 = grid.WalkPathDistance(sourcePosition, sourceCubeFace0, targetPosition, targetCubeFace);
Assert.AreEqual(dist0, 14);
var dist1 = grid.WalkPathDistance(sourcePosition, sourceCubeFace1, targetPosition, targetCubeFace);
Assert.AreEqual(dist1, 32);
var dist2 = grid.WalkPathDistance(sourcePosition, sourceCubeFace2, targetPosition, targetCubeFace);
Assert.AreEqual(dist2, 30);
var dist3 = grid.WalkPathDistance(sourcePosition, sourceCubeFace3, targetPosition, targetCubeFace);
Assert.AreEqual(dist3, 16);
var dist4 = grid.WalkPathDistance(sourcePosition, sourceCubeFace4, targetPosition, targetCubeFace);
Assert.AreEqual(dist4, 17);
var dist5 = grid.WalkPathDistance(sourcePosition, sourceCubeFace5, targetPosition, targetCubeFace);
Assert.AreEqual(dist5, 31);
}
}
public void Init()
{
HttpContext.Current = new HttpContext(
new HttpRequest("", "http://tempuri.org", ""),
new HttpResponse(new StringWriter()));
var repo = new TestRepository();
var items = repo.GetAll().ToList();
_grid = new TestGrid(items);
_columns = new GridColumnCollection <TestModel>(new DefaultColumnBuilder <TestModel>(_grid, new GridAnnotaionsProvider()), _grid.Settings.SortSettings);
}
public void TestSortingStringDescending()
{
Action <IGridColumnCollection <TestModel> > columns = c =>
{
c.Add(x => x.Title).Sortable(true);
};
var grid = new TestGrid((q) => _repo.GetAllService(columns, q), true, columns, Thread.CurrentThread.CurrentCulture);
if (
!ValidateSorting <string, object>(grid, x => x.Title, "Title", GridSortDirection.Descending, null, null))
{
Assert.Fail("Sort works incorrect");
}
}
public void Init()
{
HttpContext.Current = new HttpContext(
new HttpRequest("", "http://tempuri.org", ""),
new HttpResponse(new StringWriter()));
var repo = new TestRepository();
var items = repo.GetAll().ToList();
_grid = new TestGrid(items);
_columns = new GridColumnCollection<TestModel>(new DefaultColumnBuilder<TestModel>(_grid, new GridAnnotaionsProvider()), _grid.Settings.SortSettings);
}
private void TestFiltering <T>(ColumnFilterValue settings, Expression <Func <TestModel, T> > column,
Func <TestModel, bool> filterContraint)
{
Action <IGridColumnCollection <TestModel> > columns = c =>
{
c.Add(column, settings.ColumnName).Filterable(true);
};
var grid = new TestGrid((q) => _repo.GetAllService(columns, q, false, true), true, columns, Thread.CurrentThread.CurrentCulture);
if (!ValidateFiltering(grid, grid.Columns.GetByName(settings.ColumnName), settings, filterContraint))
{
Assert.Fail("Filtering works incorrect");
}
}
public void TestSortingIntAscending()
{
Action <IGridColumnCollection <TestModel> > columns = c =>
{
c.Add(x => x.Id).Sortable(true);
};
var grid = new TestGrid((q) => _repo.GetAllService(columns, q, false, true), true, columns, Thread.CurrentThread.CurrentCulture);
if (
!ValidateSorting <int, object>(grid, x => x.Id, "Id", GridSortDirection.Ascending, null,
null, null, null))
{
Assert.Fail("Sort works incorrect");
}
}
public void TestSortingStringAscendingWithCustomColumnInternalName()
{
Action <IGridColumnCollection <TestModel> > columns = c =>
{
c.Add(x => x.Title, "someid").Sortable(true);
};
var grid = new TestGrid((q) => _repo.GetAllService(columns, q, false, true), true, columns, Thread.CurrentThread.CurrentCulture);
if (
!ValidateSorting <string, object>(grid, x => x.Title, "someid",
GridSortDirection.Ascending, null, null, null, null))
{
Assert.Fail("Sort works incorrect");
}
}
public void TestFilteringDateTimeLessThanWithCustomInternalColumnName()
{
var filterValue = new DateTime(2005, 5, 10);
var settings = MockFilterSetting("someid", filterValue.ToString("d"), GridFilterType.LessThan);
Action <IGridColumnCollection <TestModel> > columns = c =>
{
c.Add(x => x.Created, "someid").Filterable(true);
};
var grid = new TestGrid((q) => _repo.GetAllService(columns, q), true, columns, Thread.CurrentThread.CurrentCulture);
if (!ValidateFiltering(grid, settings, x => x.Created < filterValue))
{
Assert.Fail("Filtering works incorrect");
}
}
public void TestSortingChildStringAscending()
{
Action <IGridColumnCollection <TestModel> > columns = c =>
{
c.Add(x => x.Child.ChildTitle);
};
var grid = new TestGrid((q) => _repo.GetAllService(columns, q, false, true), true, columns, Thread.CurrentThread.CurrentCulture);
grid.ExtSortingEnabled = true;
if (
!ValidateSorting <string, object>(grid, x => x.Child.ChildTitle, "Child.ChildTitle", GridSortDirection.Ascending, null, null, null))
{
Assert.Fail("Extended sort works incorrect");
}
}
public void TestSortingThenByDescending()
{
Action <IGridColumnCollection <TestModel> > columns = c =>
{
c.Add(x => x.Child.ChildCreated).Sortable(true).ThenSortByDescending(x => x.Title);
};
var grid = new TestGrid((q) => _repo.GetAllService(columns, q), true, columns, Thread.CurrentThread.CurrentCulture);
if (
!ValidateSorting(grid, x => x.Child.ChildCreated, "Child.ChildCreated",
GridSortDirection.Ascending, x => x.Title, GridSortDirection.Descending))
{
Assert.Fail("Sort works incorrect");
}
}
public void TestSortingChildDateTimeDescendingWithCustomInternalColumnName()
{
Action <IGridColumnCollection <TestModel> > columns = c =>
{
c.Add(x => x.Child.ChildCreated, "someid").Sortable(true);
};
var grid = new TestGrid((q) => _repo.GetAllService(columns, q), true, columns, Thread.CurrentThread.CurrentCulture);
if (
!ValidateSorting <DateTime, object>(grid, x => x.Child.ChildCreated,
"someid", GridSortDirection.Descending, null,
null))
{
Assert.Fail("Sort works incorrect");
}
}
