Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 3
0
        public void SelectCornerCell(MoveDirection d)
        {
            BvgCell <TItem> bvgActiveCell = bvgCell.bvgGrid.ActiveBvgCell;

            switch (d)
            {
            case MoveDirection.right:
                if (!bvgActiveCell.bvgGrid.HorizontalScroll.compBlazorScrollbar.IsOnMaxPosition())
                {
                    NavigationHelper <TItem> .SelectAndScrollIntoViewHorizontal(true, bvgActiveCell.bvgGrid.ColumnsOrderedListNonFrozen.Last().prop.Name, bvgActiveCell.bvgRow.IndexInSource, bvgActiveCell.bvgGrid);
                }
                else
                {
                    if (!bvgActiveCell.bvgColumn.prop.Name.Equals(bvgActiveCell.bvgGrid.ColumnsOrderedListNonFrozen.Last().prop.Name))
                    {
                        NavigationHelper <TItem> .SelectAndScrollIntoViewHorizontal(true, bvgActiveCell.bvgGrid.ColumnsOrderedListNonFrozen.Last().prop.Name, bvgActiveCell.bvgRow.IndexInSource, bvgActiveCell.bvgGrid);
                    }
                }
                break;

            case MoveDirection.left:
                if (!bvgActiveCell.bvgGrid.HorizontalScroll.compBlazorScrollbar.IsOnMinPosition())
                {
                    NavigationHelper <TItem> .SelectAndScrollIntoViewHorizontal(true, bvgActiveCell.bvgGrid.ColumnsOrderedList.First().prop.Name, bvgActiveCell.bvgRow.IndexInSource, bvgActiveCell.bvgGrid, 0);
                }
                else
                {
                    if (!bvgActiveCell.bvgColumn.prop.Name.Equals(bvgActiveCell.bvgGrid.ColumnsOrderedList.First().prop.Name))
                    {
                        NavigationHelper <TItem> .SelectAndScrollIntoViewHorizontal(true, bvgActiveCell.bvgGrid.ColumnsOrderedList.First().prop.Name, bvgActiveCell.bvgRow.IndexInSource, bvgActiveCell.bvgGrid, 0);
                    }
                }
                break;

            case MoveDirection.up:
                if (bvgActiveCell.bvgRow.IndexInSource > 1)
                {
                    bvgActiveCell.bvgGrid.VerticalScroll.compBlazorScrollbar.SetScrollPosition(0);
                }

                if (bvgActiveCell.bvgRow.IndexInSource > 1)
                {
                    BvgCell <TItem> c = bvgActiveCell.bvgGrid.Rows.Single(x => x.IndexInSource == 1).Cells.Single(x => x.bvgColumn.ID == bvgActiveCell.bvgColumn.ID);

                    bvgActiveCell.bvgGrid.SelectCell(c, true);
                }
                break;

            case MoveDirection.down:
                int MaxID = bvgActiveCell.bvgGrid.Rows.Max(x => x.ID);

                if (bvgActiveCell.bvgRow.IndexInSource < bvgActiveCell.bvgGrid.RowsTotalCount)
                {
                    bvgActiveCell.bvgGrid.VerticalScroll.compBlazorScrollbar.SetScrollPosition(bvgActiveCell.bvgGrid.RowsTotalCount * bvgActiveCell.bvgGrid.bvgSettings.RowHeight);
                }

                if (bvgActiveCell.bvgRow.ID < MaxID - 1)
                {
                    BvgCell <TItem> c = bvgActiveCell.bvgGrid.Rows.Single(x => x.ID == MaxID - 1).Cells.Single(x => x.bvgColumn.ID == bvgActiveCell.bvgColumn.ID);

                    bvgActiveCell.bvgGrid.SelectCell(c, true);
                }
                break;

            default:
                break;
            }
        }
Ejemplo n.º 4
0
        public void SelectNeightbourCell(MoveDirection d)
        {
            //BlazorWindowHelper.BWHJsInterop.jsRuntime = BvgJsInterop.jsRuntime;
            //BlazorWindowHelper.BlazorTimeAnalyzer.Reset();
            //BlazorWindowHelper.BlazorTimeAnalyzer.Add("A1", MethodBase.GetCurrentMethod());

            int StepSize = 1;

            //After refresh from JS bvgCell for this component is old because we don't do component refresh
            //So we will depend Active cell data because it is always up to date.
            BvgCell <TItem> bvgActiveCell = bvgCell.bvgGrid.ActiveBvgCell;

            int     sn    = 0;
            ColProp a     = new ColProp();
            int     index = 0;

            switch (d)
            {
            case MoveDirection.right:
                a     = bvgActiveCell.bvgGrid.ColumnsOrderedList.Single(x => x.prop.Name.Equals(bvgActiveCell.bvgColumn.prop.Name));
                index = bvgActiveCell.bvgGrid.ColumnsOrderedList.ToList().IndexOf(a);

                if (index < bvgActiveCell.bvgGrid.ColumnsOrderedList.Count() - StepSize)
                {
                    if (bvgActiveCell.bvgRow.Cells.Any(x => x.bvgColumn.prop.Name.Equals(bvgActiveCell.bvgGrid.ColumnsOrderedList[index + StepSize].prop.Name)))
                    {
                        BvgCell <TItem> c = bvgActiveCell.bvgRow.Cells.Single(x => x.bvgColumn.prop.Name.Equals(bvgActiveCell.bvgGrid.ColumnsOrderedList[index + StepSize].prop.Name));
                        bvgActiveCell.bvgGrid.SelectCell(c, true);
                    }
                    else
                    {
                        NavigationHelper <TItem> .SelectAndScrollIntoViewHorizontal(false, bvgActiveCell.bvgGrid.ColumnsOrderedList[index + StepSize].prop.Name, bvgActiveCell.bvgRow.IndexInSource, bvgActiveCell.bvgGrid);
                    }
                }
                break;

            case MoveDirection.left:

                a     = bvgActiveCell.bvgGrid.ColumnsOrderedList.Single(x => x.prop.Name.Equals(bvgActiveCell.bvgColumn.prop.Name));
                index = bvgActiveCell.bvgGrid.ColumnsOrderedList.ToList().IndexOf(a);

                if (index > 0)
                {
                    if (bvgActiveCell.bvgRow.Cells.Any(x => x.bvgColumn.prop.Name.Equals(bvgActiveCell.bvgGrid.ColumnsOrderedList[index - StepSize].prop.Name)))
                    {
                        BvgCell <TItem> c = bvgActiveCell.bvgRow.Cells.Single(x => x.bvgColumn.prop.Name.Equals(bvgActiveCell.bvgGrid.ColumnsOrderedList[index - StepSize].prop.Name));

                        bvgActiveCell.bvgGrid.SelectCell(c, true);
                    }
                    else
                    {
                        NavigationHelper <TItem> .SelectAndScrollIntoViewHorizontal(true, bvgActiveCell.bvgGrid.ColumnsOrderedList[index - StepSize].prop.Name, bvgActiveCell.bvgRow.IndexInSource, bvgActiveCell.bvgGrid);
                    }
                }

                break;

            case MoveDirection.up:
                sn = bvgActiveCell.bvgRow.ID - StepSize;

                if (bvgActiveCell.bvgGrid.Rows.Any(x => x.ID == sn))
                {
                    BvgCell <TItem> c = bvgActiveCell.bvgGrid.Rows.Single(x => x.ID == sn).Cells.Single(x => x.bvgColumn.ID == bvgActiveCell.bvgColumn.ID);

                    bvgActiveCell.bvgGrid.SelectCell(c, true);
                }
                else
                {
                    if (bvgActiveCell.bvgRow.IndexInSource > 1)
                    {
                        if (bvgActiveCell.bvgRow.IndexInSource > StepSize)
                        {
                            NavigationHelper <TItem> .ScrollIntoViewVertical(true, (ushort)(bvgActiveCell.bvgRow.IndexInSource - StepSize), bvgActiveCell.bvgColumn.prop.Name, bvgActiveCell.bvgGrid);
                        }
                    }
                }
                break;

            case MoveDirection.down:
                int MaxID = bvgActiveCell.bvgGrid.Rows.Max(x => x.ID);
                sn = bvgActiveCell.bvgRow.ID + StepSize;

                if (bvgActiveCell.bvgGrid.Rows.Any(x => x.ID == sn) && sn < MaxID - 1)
                {
                    BvgCell <TItem> c = bvgActiveCell.bvgGrid.Rows.Single(x => x.ID == sn).Cells.Single(x => x.bvgColumn.ID == bvgActiveCell.bvgColumn.ID);

                    bvgActiveCell.bvgGrid.SelectCell(c, true);
                }
                else
                {
                    if (bvgActiveCell.bvgRow.IndexInSource < bvgCell.bvgGrid.RowsTotalCount)
                    {
                        int tmpindex = bvgCell.bvgGrid.ActiveBvgCell.bvgRow.IndexInSource;

                        NavigationHelper <TItem> .ScrollIntoViewVertical(false, (ushort)(bvgActiveCell.bvgRow.IndexInSource + 1), bvgActiveCell.bvgColumn.prop.Name, bvgActiveCell.bvgGrid);


                        if (tmpindex == bvgCell.bvgGrid.ActiveBvgCell.bvgRow.IndexInSource)
                        {
                            NavigationHelper <TItem> .ScrollIntoViewVertical(false, (ushort)(bvgActiveCell.bvgRow.IndexInSource + 2), bvgActiveCell.bvgColumn.prop.Name, bvgActiveCell.bvgGrid);
                        }


                        if (tmpindex == bvgCell.bvgGrid.ActiveBvgCell.bvgRow.IndexInSource)
                        {
                            SelectCornerCell(d);
                        }
                    }
                }
                break;

            default:
                break;
            }



            // BlazorWindowHelper.BlazorTimeAnalyzer.Log();
        }
Ejemplo n.º 5
0
        public void SelectNeightbourCell(MoveDirection d, bool HasCtrl)
        {
            BvgCell result = new BvgCell();
            int     sn     = 0;

            switch (d)
            {
            case MoveDirection.right:
                if (HasCtrl)
                {
                    if (!bvgCell.bvgGrid.HorizontalScroll.compBlazorScrollbar.IsOnMaxPosition())
                    {
                        bvgCell.bvgGrid.HorizontalScroll.compBlazorScrollbar.SetScrollPosition(bvgCell.bvgGrid.NonFrozenTableWidth);
                    }

                    if (bvgCell.bvgColumn.ID < bvgCell.bvgGrid.Columns.Max(x => x.ID))
                    {
                        BvgCell c = bvgCell.bvgRow.Cells.Single(x => x.bvgColumn.ID == bvgCell.bvgGrid.Columns.Max(x2 => x2.ID));

                        bvgCell.bvgGrid.SelectCell(c, true);
                    }
                }
                else
                {
                    if (bvgCell.bvgColumn.ID < bvgCell.bvgGrid.Columns.Max(x2 => x2.ID))
                    {
                        sn = bvgCell.bvgColumn.ID + 1;


                        if (bvgCell.bvgRow.Cells.Where(x => x.HasCol).Any(x => x.bvgColumn.ID == sn))
                        {
                            BvgCell c = bvgCell.bvgRow.Cells.Single(x => x.bvgColumn.ID == sn);

                            bvgCell.bvgGrid.SelectCell(c, true);
                        }
                        else
                        {
                            if (!bvgCell.bvgGrid.HorizontalScroll.compBlazorScrollbar.IsOnMaxPosition())
                            {
                                bvgCell.bvgGrid.HorizontalScroll.compBlazorScrollbar
                                .ThumbMove(bvgCell.bvgGrid.Columns.Single(x => x.ID == sn).ColWidth);

                                BvgCell c = bvgCell.bvgRow.Cells.Single(x => x.bvgColumn.ID == sn);
                                bvgCell.bvgGrid.SelectCell(c, true);
                            }
                        }
                    }
                }
                break;

            case MoveDirection.left:
                if (HasCtrl)
                {
                    if (!bvgCell.bvgGrid.HorizontalScroll.compBlazorScrollbar.IsOnMinPosition())
                    {
                        bvgCell.bvgGrid.HorizontalScroll.compBlazorScrollbar.SetScrollPosition(0);
                    }

                    if (bvgCell.bvgColumn.ID > 0)
                    {
                        BvgCell c = bvgCell.bvgRow.Cells.Single(x => x.bvgColumn.ID == 0);

                        bvgCell.bvgGrid.SelectCell(c, true);
                    }
                }
                else
                {
                    if (bvgCell.bvgColumn.ID > 0)
                    {
                        sn = bvgCell.bvgColumn.ID - 1;

                        if (bvgCell.bvgRow.Cells.Where(x => x.HasCol).Any(x => x.bvgColumn.ID == sn))
                        {
                            BvgCell c = bvgCell.bvgRow.Cells.Single(x => x.bvgColumn.ID == sn);

                            bvgCell.bvgGrid.SelectCell(c, true);
                        }
                        else
                        {
                            if (!bvgCell.bvgGrid.HorizontalScroll.compBlazorScrollbar.IsOnMinPosition())
                            {
                                bvgCell.bvgGrid.HorizontalScroll.compBlazorScrollbar
                                .ThumbMove(-bvgCell.bvgGrid.Columns.Single(x => x.ID == sn).ColWidth);

                                BvgCell c = bvgCell.bvgRow.Cells.Single(x => x.bvgColumn.ID == sn);
                                bvgCell.bvgGrid.SelectCell(c, true);
                            }
                        }
                    }
                }
                break;

            case MoveDirection.up:
                if (HasCtrl)
                {
                    if (!bvgCell.bvgGrid.VericalScroll.compBlazorScrollbar.IsOnMinPosition())
                    {
                        bvgCell.bvgGrid.VericalScroll.compBlazorScrollbar.SetScrollPosition(0);
                    }

                    if (bvgCell.bvgRow.ID > 0)
                    {
                        BvgCell c = bvgCell.bvgGrid.Rows.Single(x => x.ID == 0).Cells.Single(x => x.bvgColumn.ID == bvgCell.bvgColumn.ID);

                        bvgCell.bvgGrid.SelectCell(c, true);
                    }
                }
                else
                {
                    sn = bvgCell.bvgRow.ID - 1;

                    if (bvgCell.bvgGrid.Rows.Any(x => x.ID == sn))
                    {
                        BvgCell c = bvgCell.bvgGrid.Rows.Single(x => x.ID == sn).Cells.Single(x => x.bvgColumn.ID == bvgCell.bvgColumn.ID);

                        bvgCell.bvgGrid.SelectCell(c, true);
                    }
                    else
                    {
                        if (!bvgCell.bvgGrid.VericalScroll.compBlazorScrollbar.IsOnMinPosition())
                        {
                            bvgCell.bvgGrid.VericalScroll.compBlazorScrollbar
                            .ThumbMove(-bvgCell.bvgGrid.RowHeightOriginal);
                        }
                    }
                }

                break;

            case MoveDirection.down:
                if (HasCtrl)
                {
                    if (!bvgCell.bvgGrid.VericalScroll.compBlazorScrollbar.IsOnMaxPosition())
                    {
                        bvgCell.bvgGrid.VericalScroll.compBlazorScrollbar.SetScrollPosition(bvgCell.bvgGrid.RowsTotalCount * bvgCell.bvgGrid.RowHeightOriginal);
                    }

                    if (bvgCell.bvgRow.ID < bvgCell.bvgGrid.Rows.Max(x => x.ID))
                    {
                        BvgCell c = bvgCell.bvgGrid.Rows.Single(x => x.ID == bvgCell.bvgGrid.Rows.Max(x2 => x2.ID)).Cells.Single(x => x.bvgColumn.ID == bvgCell.bvgColumn.ID);

                        bvgCell.bvgGrid.SelectCell(c, true);
                    }
                }
                else
                {
                    sn = bvgCell.bvgRow.ID + 1;

                    if (bvgCell.bvgGrid.Rows.Any(x => x.ID == sn))
                    {
                        BvgCell c = bvgCell.bvgGrid.Rows.Single(x => x.ID == sn).Cells.Single(x => x.bvgColumn.ID == bvgCell.bvgColumn.ID);

                        bvgCell.bvgGrid.SelectCell(c, true);
                    }
                    else
                    {
                        if (!bvgCell.bvgGrid.VericalScroll.compBlazorScrollbar.IsOnMaxPosition())
                        {
                            bvgCell.bvgGrid.VericalScroll.compBlazorScrollbar
                            .ThumbMove(bvgCell.bvgGrid.RowHeightOriginal);
                        }
                    }
                }

                break;

            default:
                break;
            }
        }