Example #1
0
        private T GetCellDecorator(IItemInfoNode parentRow, ItemInfo columnItemInfo, int rowLine, int columnLine)
        {
            Dictionary <int, T> columnCellsPair;

            if (!this.generatedRowCells.TryGetValue(rowLine, out columnCellsPair))
            {
                columnCellsPair = new Dictionary <int, T>();
                this.generatedRowCells[rowLine] = columnCellsPair;
            }

            var cellValue = this.table.GetCellValue(parentRow.ItemInfo, columnItemInfo);

            bool isFrozen = false;

            if (columnItemInfo.Item is DataGridColumn)
            {
                isFrozen = (columnItemInfo.Item as DataGridColumn).IsFrozen;
            }

            var context = new CellGenerationContext(parentRow.ItemInfo.Item, columnItemInfo.Item, cellValue, isFrozen);

            object containerType = this.containerGenerator.ContainerTypeForItem(context);

            if (containerType == null)
            {
                return(null);
            }

            T cellDecorator;

            if (!columnCellsPair.TryGetValue(columnLine, out cellDecorator))
            {
                cellDecorator = this.containerGenerator.GenerateContainer(context);
                columnCellsPair.Add(columnLine, cellDecorator);

                cellDecorator.layoutSlot  = RadRect.Invalid;
                cellDecorator.DesiredSize = RadSize.Invalid;
                cellDecorator.parent      = parentRow as Element;
            }

            if (!object.Equals(cellDecorator.Value, cellValue) || cellDecorator.Column != columnItemInfo.Item || cellDecorator.Column.ShouldRefreshCell(cellDecorator))
            {
                cellDecorator.Value           = cellValue;
                cellDecorator.Column          = columnItemInfo.Item as DataGridColumn;
                cellDecorator.Column.ItemInfo = columnItemInfo;

                this.containerGenerator.PrepareContainerForItem(cellDecorator);
            }

            return(cellDecorator);
        }
Example #2
0
        private void UpdateReadOnlyRowOpacity(IItemInfoNode rowDecorator)
        {
            var row = rowDecorator as GridRowModel;

            if (!this.isInEditMode || row == null)
            {
                return;
            }

            if (this.EditRowPool.ReadOnlyItemInfo.Equals(row.ItemInfo))
            {
                this.HideRow(row);
            }
            else
            {
                this.ShowRow(row);
            }
        }
Example #3
0
        internal bool GenerateCellsForRow(IItemInfoNode rowDecorator, int rowSlot)
        {
            var rowItem = rowDecorator.ItemInfo.Item;

            var isPlaceHolder = rowItem is PlaceholderInfo;

            if (rowItem is IGroup || isPlaceHolder)
            {
                return(false);
            }

            double desiredWidth = 0;

            bool shouldUpdateColumns = false;

            double availableWidth = this.ColumnPool.AvailableLength;

            int generatedCellCount = 0;

            var  columns   = this.ColumnPool.GetDisplayedElements().ToArray();
            bool generated = this.generatedRowCells.ContainsKey(rowSlot);

            foreach (var columnPairs in columns)
            {
                int columnLine      = columnPairs.Key;
                var columnDecorator = columnPairs.Value.LastOrDefault();
                Debug.Assert(columnDecorator != null, "Decorator shoundn't be null");

                int columnSlot = columnLine;
                generatedCellCount++;

                T cellModel = null;
                if (generated)
                {
                    var cellsPerLine = this.generatedRowCells[rowSlot];
                    cellsPerLine.TryGetValue(columnLine, out cellModel);
                }

                if (cellModel == null)
                {
                    cellModel = this.GetCellDecorator(rowDecorator, columnDecorator.ItemInfo, rowSlot, columnLine);
                }

                if (cellModel != null)
                {
                    cellModel.parent = rowDecorator as Element;
                }

                var    desiredSize = this.MeasureCellDecorator(cellModel);
                double cellWidth   = desiredSize.Width;
                double cellHeight  = desiredSize.Height;

                this.UpdateSlotHeight(rowSlot, cellHeight);
                bool slotWidthUpdated = this.UpdateSlotWidth(columnSlot, cellWidth);
                shouldUpdateColumns = shouldUpdateColumns || slotWidthUpdated;

                desiredWidth += this.GetSlotWidth(columnSlot);
                if (generatedCellCount == 1)
                {
                    desiredWidth -= this.ColumnPool.HiddenPixels;
                }

                if (GridModel.DoubleArithmetics.IsGreaterThan(desiredWidth, availableWidth))
                {
                    break;
                }
            }

            // TODO:Handle this better in frozen columns scenario
            shouldUpdateColumns = generatedCellCount != this.ColumnPool.ViewportItemCount && this.table.FrozenColumnCount == 0 || shouldUpdateColumns;

            return(shouldUpdateColumns);
        }
Example #4
0
        internal bool GenerateCellsForColumn(IItemInfoNode columnDecorator, int columnSlot)
        {
            double desiredHeight = 0;

            double availableHeight = this.RowPool.AvailableLength;
            double availableWidth  = this.ColumnPool.AvailableLength;

            bool shouldUpdateRows = false;

            int generatedCellCount = 0;

            var rows = this.RowPool.GetDisplayedElements().ToArray();

            foreach (var rowPairs in rows)
            {
                int rowSlot      = rowPairs.Key;
                var rowDecorator = rowPairs.Value.LastOrDefault();
                Debug.Assert(rowDecorator != null, "Decorator shoundn't be null");

                generatedCellCount++;
                bool isGroup       = rowDecorator.ItemInfo.Item is IGroup;
                bool isPlaceHolder = rowDecorator.ItemInfo.Item is PlaceholderInfo;

                if (isGroup || isPlaceHolder)
                {
                    desiredHeight += rowDecorator.DesiredSize.Height;
                    continue;
                }
                T cellModel = null;

                if (this.generatedRowCells.ContainsKey(rowSlot))
                {
                    var cellsPerLine = this.generatedRowCells[rowSlot];
                    if (isGroup)
                    {
                        Debug.Assert(cellsPerLine.Count < 2, "Groups should have 1 cell only");
                        if (cellsPerLine.Count == 1)
                        {
                            cellModel = cellsPerLine.First().Value;
                        }
                    }
                    else
                    {
                        cellsPerLine.TryGetValue(columnSlot, out cellModel);
                    }
                }

                if (cellModel == null)
                {
                    cellModel = this.GetCellDecorator(rowDecorator, columnDecorator.ItemInfo, rowSlot, columnSlot);
                }

                if (cellModel != null)
                {
                    cellModel.parent = rowDecorator;
                }

                var    desiredSize = this.MeasureCellDecorator(cellModel);
                double cellWidth   = desiredSize.Width;
                double cellHeigth  = desiredSize.Height;

                this.UpdateSlotWidth(columnSlot, cellWidth);
                bool slotHeightUpdated = this.UpdateSlotHeight(rowSlot, cellHeigth);
                shouldUpdateRows = shouldUpdateRows || slotHeightUpdated;

                desiredHeight += this.GetSlotHeight(rowSlot);
                if (generatedCellCount == 1)
                {
                    desiredHeight -= this.RowPool.HiddenPixels;
                }

                if (GridModel.DoubleArithmetics.IsGreaterThan(desiredHeight, availableHeight))
                {
                    break;
                }
            }

            shouldUpdateRows = generatedCellCount != this.RowPool.ViewportItemCount || shouldUpdateRows;

            return(shouldUpdateRows);
        }
Example #5
0
        double ITable.GenerateCellsForColumn(int columnSlot, double largestColumnElementWidth, IItemInfoNode columnDecorator)
        {
            this.CellsController.UpdateSlotWidth(columnSlot, largestColumnElementWidth);

            Debug.Assert(columnDecorator != null, "Decorator shoundn't be null");
            bool shouldUpdateRows = this.CellsController.GenerateCellsForColumn(columnDecorator, columnSlot);

            if (shouldUpdateRows)
            {
                this.InvalidateRowsMeasure();
            }

            return(this.CellsController.GetSlotWidth(columnSlot));
        }
Example #6
0
        private double GenerateCellsForEditRow(int rowSlot, double largestRowElementWidth, IItemInfoNode rowDecorator)
        {
            this.CellEditorsController.UpdateSlotHeight(rowSlot, largestRowElementWidth);

            Debug.Assert(rowDecorator != null, "Decorator shoundn't be null");
            bool shouldUpdateColumns = this.CellEditorsController.GenerateCellsForRow(rowDecorator, rowSlot);

            if (shouldUpdateColumns)
            {
                this.GridView.InvalidateHeadersPanelMeasure();
                this.GridView.InvalidateCellsPanelMeasure();
            }

            var desiredHeight = this.CellEditorsController.GetSlotHeight(rowSlot);

            this.EditRowPool.RenderInfo.Update(rowSlot, desiredHeight);

            return(desiredHeight);
        }
Example #7
0
        double ITable.GenerateCellsForRow(int rowSlot, double largestRowElementHeight, IItemInfoNode rowDecorator)
        {
            if (this.isInEditMode && rowDecorator == this.EditRow || rowDecorator == this.FrozenEditRow)
            {
                return(this.GenerateCellsForEditRow(rowSlot, largestRowElementHeight, rowDecorator));
            }
            else
            {
                var height = this.GenerateCellsForReadOnlyRow(rowSlot, largestRowElementHeight, rowDecorator);

                this.UpdateReadOnlyRowOpacity(rowDecorator);

                return(height);
            }
        }
Example #8
0
        private double GenerateCellsForReadOnlyRow(int rowSlot, double largestRowElementWidth, IItemInfoNode rowDecorator)
        {
            this.CellsController.UpdateSlotHeight(rowSlot, 0, this.HasExpandedRowDetails(rowSlot));

            Debug.Assert(rowDecorator != null, "Decorator shoundn't be null");
            bool shouldUpdateColumns = this.CellsController.GenerateCellsForRow(rowDecorator, rowSlot);

            if (shouldUpdateColumns)
            {
                this.GridView.InvalidateHeadersPanelMeasure();
                this.GridView.InvalidateCellsPanelMeasure();
            }

            var desiredHeight = this.CellsController.GetSlotHeight(rowSlot);

            var maxHeight = Math.Max(desiredHeight, largestRowElementWidth);

            this.rowLayout.RenderInfo.Update(rowSlot, maxHeight);

            return(desiredHeight);
        }