private static BvgCell GetCell(BvgRow row, BvgColumn col, T item, BvgGrid _bvgGrid, bool SetValue)
{
BvgCell cell = new BvgCell
{
bvgRow = row,
bvgColumn = col,
HasCol = true,
bvgGrid = _bvgGrid,
};
if (SetValue)
{
cell.Value = col.prop.GetValue(item, null).ToString();
}
if (col.IsFrozen)
{
cell.CssClass = CellStyle.CellFrozen.ToString();
}
else
{
cell.CssClass = CellStyle.CellNonFrozen.ToString();
}
cell.UpdateID();
return(cell);
}
public static void GetColumns(ColProp[] props, BvgGrid <T> _bvgGrid, T[] list, bool UpdateUI)
{
int h = _bvgGrid.bvgSettings.HeaderHeight - 10;
if (!_bvgGrid.Columns.Any())
{
_bvgGrid.Columns = new BvgColumn <T> [props.Count()];
for (ushort i = 0; i < props.Count(); i++)
{
_bvgGrid.Columns[i] = getCol(i, props[i], h, _bvgGrid);
}
}
else
{
_bvgGrid.Columns = new BvgColumn <T> [props.Count()];
string[] UpdatePkg = new string[props.Count() * 4];
short j = -1;
for (ushort i = 0; i < props.Count(); i++)
{
_bvgGrid.Columns[i] = getCol(i, props[i], h, _bvgGrid);
UpdatePkg[++j] = i.ToString();
UpdatePkg[++j] = props[i].prop.Name;
UpdatePkg[++j] = _bvgGrid.Columns[i].ColWidth.ToString();
UpdatePkg[++j] = _bvgGrid.Columns[i].ColWidthSpan.ToString();
}
if (_bvgGrid.Rows.Any())
{
foreach (BvgRow <T> r in _bvgGrid.Rows)
{
foreach (BvgCell <T> c in r.Cells)
{
c.bvgColumn = _bvgGrid.Columns[c.bvgColumn.ID];
}
}
}
if (UpdateUI)
{
BVirtualGridCJsInterop.UpdateColContentsBatch(UpdatePkg);
RefreshRows(list, _bvgGrid, true, 0);
}
}
if (_bvgGrid.SortState.Item1)
{
if (_bvgGrid.Columns.Any(x => x.prop.Name.Equals(_bvgGrid.SortState.Item2)))
{
BvgColumn <T> sortedCol2 = _bvgGrid.Columns.Single(x => x.prop.Name.Equals(_bvgGrid.SortState.Item2));
sortedCol2.IsSorted = true;
sortedCol2.IsAscendingOrDescending = _bvgGrid.SortState.Item3;
}
}
}
private static void RefreshRows(T[] list, BvgGrid _bvgGrid, bool updateWidths)
{
short i = -1;
short i2 = -1;
byte g = 0;
string[] UpdatePkg = new string[_bvgGrid.Rows.Count() * _bvgGrid.Rows[0].Cells.Count() * 3];
string[] UpdatePkg2 = new string[1];
if (updateWidths)
{
UpdatePkg2 = new string[_bvgGrid.Rows.Count() * _bvgGrid.Rows[0].Cells.Count() * 3];
}
foreach (T item in list)
{
foreach (BvgCell c in _bvgGrid.Rows[g].Cells.Where(x => x.HasCol))
{
c.Value = c.bvgColumn.prop.GetValue(item, null).ToString();
UpdatePkg[++i] = c.ID;
UpdatePkg[++i] = c.Value;
if (c.bvgColumn.prop.PropertyType.Equals(typeof(bool)))
{
UpdatePkg[++i] = "b";
}
else
{
UpdatePkg[++i] = "s";
}
if (updateWidths)
{
UpdatePkg2[++i2] = c.ID;
UpdatePkg2[++i2] = c.bvgColumn.ColWidth.ToString();
UpdatePkg2[++i2] = c.bvgColumn.ColWidthWithoutBorder.ToString();
}
}
g++;
}
BvgJsInterop.UpdateRowContentBatch(UpdatePkg);
if (updateWidths)
{
BvgJsInterop.UpdateRowWidthsBatch(UpdatePkg2);
}
}
public void UpdateStyle2(BvgGrid <TItem> _bvgGrid)
{
//without this it was generating old data, weird but fact.
//now we are sure that we have last version of bvgGrid state
bvgGrid = _bvgGrid;
blazorCSS.RemoveSelector(".myGridArea");
blazorCSS.RemoveSelector(".myContainerFrozen");
blazorCSS.RemoveSelector(".myContainerNonFrozen");
GenerateCSSGridmyGridArea();
GenerateCSSGridFrozenCSS();
GenerateCSSGridNonFrozenCSS();
BVirtualGridCJsInterop.UpdateStyle(StyleID2, GetString(StyleID2));
}
private static BvgColumn <T> getCol(ushort id, ColProp p, int h, BvgGrid <T> _bvgGrid)
{
return(new BvgColumn <T>
{
ID = id,
prop = p.prop,
SequenceNumber = p.SequenceNumber,
bvgGrid = _bvgGrid,
CssClass = HeaderStyle.HeaderRegular.ToString(),
IsFrozen = p.IsFrozen,
ColWidth = p.ColWidth,
bsSettings = new BsSettings(string.Concat("Splitter" + p.prop.Name))
{
VerticalOrHorizontal = false,
index = id,
width = 5,
height = h,
BgColor = _bvgGrid.bvgSettings.HeaderStyle.BackgroundColor,
//BgColor = "red",
}
});
}
//bool EnabledRender = true;
//protected override bool ShouldRender()
//{
// return EnabledRender;
//}
protected override Task OnParametersSetAsync()
{
//BlazorWindowHelper.BlazorTimeAnalyzer.LogAllAdd = true;
bvgGrid = new BvgGrid
{
IsReady = true,
Name = TableName,
RowsTotalCount = SourceList.Count(),
bvgSettings = bvgSettings,
AllProps = typeof(TItem).GetProperties(BindingFlags.Public | BindingFlags.Instance),
SortState = Tuple.Create(false, new BvgColumn()),
};
bvgGrid.ColumnsOrderedList = ColumnsHelper.GetColumnsOrderedList(bvgGrid);
bvgGrid.ColumnsOrderedListFrozen = bvgGrid.ColumnsOrderedList.Where(x => x.IsFrozen).ToArray();
bvgGrid.ColumnsOrderedListNonFrozen = bvgGrid.ColumnsOrderedList.Where(x => x.IsFrozen == false).ToArray();
ColProp[] c = bvgGrid.ColumnsOrderedList.Where(x => x.IsFrozen == false).ToArray();
bvgGrid.NonFrozenColwidthSumsByElement = new int[c.Count()];
int j = 0;
for (int i = 0; i < c.Count(); i++)
{
j += c[i].ColWidth;
bvgGrid.NonFrozenColwidthSumsByElement[i] = j;
}
c = null;
SortedRowsList = SourceList.ToArray();
return(base.OnParametersSetAsync());
}
public static void GetRows(T[] list, BvgGrid _bvgGrid)
{
ushort k = 0;
if (!_bvgGrid.Rows.Any())
{
_bvgGrid.Rows = new BvgRow[list.Count()];
ushort j = 0;
ushort g = 0;
foreach (T item in list)
{
BvgRow row = new BvgRow
{
ID = k++,
bvgGrid = _bvgGrid,
Cells = new BvgCell[_bvgGrid.Columns.Count()],
};
row.IsEven = row.ID % 2 == 0;
g = 0;
foreach (BvgColumn col in _bvgGrid.Columns)
{
row.Cells[g] = GetCell(row, col, item, _bvgGrid, true);
g++;
}
_bvgGrid.Rows[j] = row;
j++;
}
}
else
{
RefreshRows(list, _bvgGrid, false);
}
}
public static void GetRows(T[] list, BvgGrid <T> _bvgGrid, ushort skip)
{
ushort k = 0;
if (!_bvgGrid.Rows.Any())
{
_bvgGrid.Rows = new BvgRow <T> [list.Count()];
ushort j = 0;
ushort g = 0;
foreach (T item in list)
{
BvgRow <T> row = new BvgRow <T>
{
ID = k++,
IndexInSource = (ushort)(k + skip),
bvgGrid = _bvgGrid,
Cells = new BvgCell <T> [_bvgGrid.Columns.Count()],
};
g = 0;
foreach (BvgColumn <T> col in _bvgGrid.Columns)
{
row.Cells[g] = GetCell(row, col, item, _bvgGrid);
g++;
}
_bvgGrid.Rows[j] = row;
j++;
}
}
else
{
RefreshRows(list, _bvgGrid, false, skip);
}
}
private static double GetScrollPositionForColumn(string ColName, bool AlignLeftOrRight, BvgGrid <TItem> _bvgGrid)
{
if (!_bvgGrid.ColumnsOrderedListNonFrozen.Any(x => x.prop.Name.Equals(ColName)))
{
return(0);
}
double result = 0;
ColProp a = _bvgGrid.ColumnsOrderedListNonFrozen.Single(x => x.prop.Name.Equals(ColName));
int index = _bvgGrid.ColumnsOrderedListNonFrozen.ToList().IndexOf(a);
string s = string.Empty;
for (int i = 0; i < _bvgGrid.NonFrozenColwidthSumsByElement.Count(); i++)
{
s += _bvgGrid.NonFrozenColwidthSumsByElement[i] + " ";
}
result = _bvgGrid.NonFrozenColwidthSumsByElement[index] - a.ColWidth + 5;
if (!AlignLeftOrRight)
{
result -= _bvgGrid.NonFrozenTableWidth;
}
return(result);
}
private static void RefreshRows(T[] list, BvgGrid <T> _bvgGrid, bool updateWidths, int skip)
{
//BlazorWindowHelper.BlazorTimeAnalyzer.Add("Refresh rows start", MethodBase.GetCurrentMethod());
short i = -1;
short i1 = -1;
short i2 = -1;
short i3 = -1;
byte g = 0;
int lenght = _bvgGrid.Rows.Count() * _bvgGrid.Rows[0].Cells.Count();
string[] PkgIDs = new string[lenght];
string[] UpdatePkg = new string[lenght * 2];
string[] UpdatePkg2 = new string[1];
if (updateWidths)
{
UpdatePkg2 = new string[lenght];
}
string[] UpdatePkgClass = new string[1];
if (!updateWidths)
{
UpdatePkgClass = new string[lenght];
}
foreach (T item in list)
{
if (!updateWidths)
{
_bvgGrid.Rows[g].IndexInSource = (ushort)(g + skip + 1);
}
foreach (BvgCell <T> c in _bvgGrid.Rows[g].Cells)
{
c.Value = c.bvgColumn.prop.GetValue(item, null).ToString();
PkgIDs[++i1] = c.ID;
UpdatePkg[++i] = c.Value;
if (c.bvgColumn.prop.PropertyType.Equals(typeof(bool)))
{
UpdatePkg[++i] = "b";
}
else
{
UpdatePkg[++i] = "s";
}
if (!updateWidths)
{
c.UpdateCssClass();
UpdatePkgClass[++i3] = c.CssClassFull;
}
if (updateWidths)
{
UpdatePkg2[++i2] = c.bvgColumn.ColWidth.ToString();
}
}
g++;
}
//BlazorWindowHelper.BlazorTimeAnalyzer.Add("js calls start", MethodBase.GetCurrentMethod());
//BlazorWindowHelper.BlazorTimeAnalyzer.Add("js calls 1 start", MethodBase.GetCurrentMethod());
BVirtualGridCJsInterop.UpdateElementContentBatchMonoByteArray(PkgIDs, UpdatePkg);
if (!updateWidths)
{
//BlazorWindowHelper.BlazorTimeAnalyzer.Add("js calls 2 start", MethodBase.GetCurrentMethod());
BVirtualGridCJsInterop.UpdateCellClassBatchMonoByteArray(PkgIDs, UpdatePkgClass);
}
if (updateWidths)
{
//BlazorWindowHelper.BlazorTimeAnalyzer.Add("js calls 3 start", MethodBase.GetCurrentMethod());
BVirtualGridCJsInterop.UpdateRowWidthsBatch(PkgIDs, UpdatePkg2);
}
//BlazorWindowHelper.BlazorTimeAnalyzer.Add("js calls end", MethodBase.GetCurrentMethod());
//BlazorWindowHelper.BlazorTimeAnalyzer.Add("Refresh rows end", MethodBase.GetCurrentMethod());
}
private static BvgCell <T> GetCell(BvgRow <T> row, BvgColumn <T> col, T item, BvgGrid <T> _bvgGrid)
{
BvgCell <T> cell = new BvgCell <T>
{
bvgRow = row,
bvgColumn = col,
bvgGrid = _bvgGrid,
Value = col.prop.GetValue(item, null).ToString(),
ID = string.Concat("C", col.ID, "R", row.ID),
};
if (col.IsFrozen)
{
cell.CssClassBase = CellStyle.CF.ToString();
}
else
{
cell.CssClassBase = CellStyle.CNF.ToString();
}
return(cell);
}
public static void ScrollIntoViewVertical(bool AlignTopOrBottom, ushort RowIndexInSource, string ColName, BvgGrid <TItem> _bvgGrid)
{
double d = (RowIndexInSource - 1) * _bvgGrid.bvgSettings.RowHeight;
if (!AlignTopOrBottom)
{
d -= (_bvgGrid.DisplayedRowsCount - 3) * _bvgGrid.bvgSettings.RowHeight;
}
_bvgGrid.ActiveCell = Tuple.Create(true, RowIndexInSource, ColName);
_bvgGrid.VerticalScroll.compBlazorScrollbar.SetScrollPosition(d);
_bvgGrid.SetScrollTop(0);
}
public CssHelper(BvgGrid <TItem> _bvgGrid)
{
bvgGrid = _bvgGrid;
GenerateCSS();
}
public static ColProp[] GetColumnsOrderedList(BvgGrid bvgGrid)
{
int ColsCount = bvgGrid.AllProps.Count() - bvgGrid.bvgSettings.HiddenColumns.Count();
ColProp[] result = new ColProp[ColsCount];
PropertyInfo[] AllPropsWithoutHidden = new PropertyInfo[ColsCount];
int j = 0;
foreach (var item in bvgGrid.AllProps)
{
if (!bvgGrid.bvgSettings.HiddenColumns.Values.Any(x => x.Equals(item.Name, StringComparison.InvariantCultureIgnoreCase)))
{
AllPropsWithoutHidden[j] = item;
j++;
}
}
bool HasFrozenColumns = bvgGrid.bvgSettings.FrozenColumnsListOrdered.Count() > 0;
bool HasNonFrozenColumnsOrdered = bvgGrid.bvgSettings.NonFrozenColumnsListOrdered.Count() > 0;
if (!HasFrozenColumns && !HasNonFrozenColumnsOrdered)
{
foreach (var item in AllPropsWithoutHidden)
{
result[j] = new ColProp()
{
prop = item,
IsFrozen = false,
};
}
}
else
{
List <OrderItem> list1 = new List <OrderItem>();
foreach (var item in AllPropsWithoutHidden)
{
list1.Add(new OrderItem
{
SequenceNumber = (ushort)(list1.Count + AllPropsWithoutHidden.Count() + 1),
Name = item.Name,
prop = item,
IsFrozen = false,
});
}
if (HasFrozenColumns && !HasNonFrozenColumnsOrdered)
{
ushort k = 0;
foreach (var item in bvgGrid.bvgSettings.FrozenColumnsListOrdered.Values)
{
if (list1.Any(x => x.Name.Equals(item, StringComparison.InvariantCultureIgnoreCase)))
{
OrderItem i = list1.Single(x => x.Name.Equals(item, StringComparison.InvariantCultureIgnoreCase));
i.SequenceNumber = k;
i.IsFrozen = true;
k++;
}
}
result = list1.OrderBy(x => x.SequenceNumber).Select(x => new ColProp {
prop = x.prop, IsFrozen = x.IsFrozen
}).ToArray();
}
if (!HasFrozenColumns && HasNonFrozenColumnsOrdered)
{
ushort k = 0;
foreach (var item in bvgGrid.bvgSettings.NonFrozenColumnsListOrdered.Values)
{
if (list1.Any(x => x.Name.Equals(item, StringComparison.InvariantCultureIgnoreCase)))
{
list1.Single(x => x.Name.Equals(item, StringComparison.InvariantCultureIgnoreCase)).SequenceNumber = k;
k++;
}
}
result = list1.OrderBy(x => x.SequenceNumber).Select(x => new ColProp {
prop = x.prop, IsFrozen = x.IsFrozen
}).ToArray();
}
if (HasFrozenColumns && HasNonFrozenColumnsOrdered)
{
ushort k = 0;
foreach (var item in bvgGrid.bvgSettings.NonFrozenColumnsListOrdered.Values)
{
if (list1.Any(x => x.Name.Equals(item, StringComparison.InvariantCultureIgnoreCase)))
{
list1.Single(x => x.Name.Equals(item, StringComparison.InvariantCultureIgnoreCase)).SequenceNumber = k;
k++;
}
}
k = (ushort)(-bvgGrid.bvgSettings.FrozenColumnsListOrdered.Count());
foreach (var item in bvgGrid.bvgSettings.FrozenColumnsListOrdered.Values)
{
if (list1.Any(x => x.Name.Equals(item, StringComparison.InvariantCultureIgnoreCase)))
{
OrderItem i = list1.Single(x => x.Name.Equals(item, StringComparison.InvariantCultureIgnoreCase));
i.SequenceNumber = k;
i.IsFrozen = true;
k++;
}
}
result = list1.OrderBy(x => x.SequenceNumber).Select(x => new ColProp {
prop = x.prop, IsFrozen = x.IsFrozen
}).ToArray();
}
}
#region SetColWidths and seqNumber
ushort seqN = 0;
foreach (var item in result)
{
item.SequenceNumber = seqN++;
if (bvgGrid.bvgSettings.ColumnWidthsDictionary.Values.Any(x => x.Item1.Equals(item.prop.Name, StringComparison.InvariantCultureIgnoreCase)))
{
ushort colwidth = bvgGrid.bvgSettings.ColumnWidthsDictionary.Values.Single(x => x.Item1.Equals(item.prop.Name, StringComparison.InvariantCultureIgnoreCase)).Item2;
if (colwidth < bvgGrid.bvgSettings.ColWidthMin)
{
colwidth = bvgGrid.bvgSettings.ColWidthMin;
}
if (colwidth > bvgGrid.bvgSettings.ColWidthMax)
{
colwidth = bvgGrid.bvgSettings.ColWidthMax;
}
item.ColWidth = colwidth;
}
else
{
item.ColWidth = bvgGrid.bvgSettings.ColWidthDefault;
}
}
#endregion
return(result);
}
public static void SelectAndScrollIntoViewHorizontal(bool AlignLeftOrRight, string ColName, ushort RowIndexInSource, BvgGrid <TItem> _bvgGrid, double p = -1)
{
double p1 = p + 5;
if (p == -1)
{
p1 = GetScrollPositionForColumn(ColName, AlignLeftOrRight, _bvgGrid);
}
_bvgGrid.HorizontalScroll.compBlazorScrollbar.SetScrollPosition(p1);
_bvgGrid.ActiveCell = Tuple.Create(true, RowIndexInSource, ColName);
_bvgGrid.HorizontalScroll.compBlazorScrollbar.SetScrollPosition(p1 - 5);
}
public static void GetColumns(ColProp[] props, BvgGrid _bvgGrid, T[] list, bool UpdateUI)
{
int h = _bvgGrid.bvgSettings.HeaderHeight - _bvgGrid.bvgSettings.HeaderStyle.BorderWidth * 2;
if (!_bvgGrid.Columns.Any())
{
_bvgGrid.Columns = new BvgColumn[props.Count()];
for (ushort i = 0; i < props.Count(); i++)
{
_bvgGrid.Columns[i] = getCol(i, props[i], h, _bvgGrid);
}
}
else
{
_bvgGrid.Columns = new BvgColumn[props.Count()];
string[] UpdatePkg = new string[props.Count() * 4];
short j = -1;
for (ushort i = 0; i < props.Count(); i++)
{
_bvgGrid.Columns[i] = getCol(i, props[i], h, _bvgGrid);
UpdatePkg[++j] = i.ToString();
UpdatePkg[++j] = props[i].prop.Name;
UpdatePkg[++j] = _bvgGrid.Columns[i].ColWidthDiv.ToString();
UpdatePkg[++j] = _bvgGrid.Columns[i].ColWidthSpan.ToString();
}
if (_bvgGrid.SortState.Item1)
{
if (_bvgGrid.Columns.Any(x => x.prop.Name.Equals(_bvgGrid.SortState.Item2.prop.Name)))
{
BvgColumn sortedCol2 = _bvgGrid.Columns.Single(x => x.prop.Name.Equals(_bvgGrid.SortState.Item2.prop.Name));
sortedCol2.IsSorted = true;
sortedCol2.IsAscendingOrDescending = _bvgGrid.SortState.Item2.IsAscendingOrDescending;
}
}
if (_bvgGrid.Rows.Any())
{
foreach (BvgRow r in _bvgGrid.Rows)
{
foreach (BvgCell c in r.Cells)
{
if (c.bvgColumn.ID < props.Count())
{
c.bvgColumn = _bvgGrid.Columns[c.bvgColumn.ID];
c.HasCol = true;
}
else
{
c.HasCol = false;
}
}
}
}
if (UpdateUI)
{
BvgJsInterop.UpdateColContentsBatch(UpdatePkg);
RefreshRows(list, _bvgGrid, true);
}
}
}
private void Reset(bool LoadColumnsFromSettings)
{
FirstLoad = true;
ActualRender = true;
LastHorizontalSkip = -1;
LastHorizontalScrollPosition = 0;
if (bvgGrid != null)
{
bvgGridTransferableState = new BvgGridTransferableState <TItem>(bvgGrid);
}
else
{
bvgGridTransferableState = new BvgGridTransferableState <TItem>();
}
bvgGrid = new BvgGrid <TItem>
{
IsReady = true,
Name = TableName,
RowsTotalCount = SourceList.Count(),
bvgSettings = bvgSettings,
AllProps = typeof(TItem).GetProperties(BindingFlags.Public | BindingFlags.Instance),
HasMeasuredRect = bvgGridTransferableState.HasMeasuredRect,
bvgSize = bvgGridTransferableState.bvgSize,
};
bvgGrid.bvgModal.bvgGrid = bvgGrid;
if (bvgGridTransferableState.ContaintState)
{
bvgGrid.cssHelper = bvgGridTransferableState.cssHelper;
}
if (bvgGridTransferableState.ContaintState && !LoadColumnsFromSettings)
{
bvgGrid.ColumnsOrderedList = bvgGridTransferableState.ColumnsOrderedList;
bvgGrid.ColumnsOrderedListFrozen = bvgGridTransferableState.ColumnsOrderedListFrozen;
bvgGrid.ColumnsOrderedListNonFrozen = bvgGridTransferableState.ColumnsOrderedListNonFrozen;
}
else
{
bvgGrid.ColumnsOrderedList = ColumnsHelper <TItem> .GetColumnsOrderedList(bvgGrid);
bvgGrid.ColumnsOrderedListFrozen = bvgGrid.ColumnsOrderedList.Where(x => x.IsFrozen).ToArray();
bvgGrid.ColumnsOrderedListNonFrozen = bvgGrid.ColumnsOrderedList.Where(x => x.IsFrozen == false).ToArray();
}
bvgGrid.UpdateNonFrozenColwidthSumsByElement();
if (bvgSettings.SortedColumn.Item1)
{
bvgGrid.SortState = Tuple.Create(bvgSettings.SortedColumn.Item1, bvgSettings.SortedColumn.Item2, bvgSettings.SortedColumn.Item3);
if (bvgSettings.SortedColumn.Item3)
{
SortedRowsList = GenericAdapter <TItem> .GetSortedRowsList(SourceList.AsQueryable(), bvgSettings.SortedColumn.Item2).ToArray();
}
else
{
SortedRowsList = GenericAdapter <TItem> .GetSortedRowsList(SourceList.AsQueryable(), bvgSettings.SortedColumn.Item2 + " desc").ToArray();
}
}
else
{
bvgGrid.SortState = Tuple.Create(false, string.Empty, false);
SortedRowsList = SourceList.ToArray();
}
}
