Esempio n. 1
0
        static CalcExpression AddRowRange(int row, int rowCount, CalcReferenceExpression dataRange)
        {
            CalcRangeExpression expression = dataRange as CalcRangeExpression;

            if (expression != null)
            {
                if (row > expression.EndRow)
                {
                    return(expression);
                }
                if (row > expression.StartRow)
                {
                    return(expression.Offset(0, 0, rowCount, 0, true, true));
                }
                return(expression.Offset(rowCount, 0, true, true) as CalcRangeExpression);
            }
            CalcExternalRangeExpression expression2 = dataRange as CalcExternalRangeExpression;

            if (expression2 == null)
            {
                return(null);
            }
            if (row > expression2.EndRow)
            {
                return(expression2);
            }
            if (row > expression2.StartRow)
            {
                return(expression2.Offset(0, 0, rowCount, 0, true, true));
            }
            return(expression2.Offset(rowCount, 0, true, true) as CalcExternalRangeExpression);
        }
Esempio n. 2
0
        static CalcExpression RemoveRowRange(int row, int rowCount, CalcReferenceExpression dataRange)
        {
            int targetEnd = (row + rowCount) - 1;
            CalcRangeExpression expression = dataRange as CalcRangeExpression;

            if (expression != null)
            {
                int resultStart = -1;
                int resultEnd   = -1;
                SubCat(expression.StartRow, expression.EndRow, row, targetEnd, ref resultStart, ref resultEnd);
                if ((resultStart > -1) && (resultEnd > -1))
                {
                    return(expression.Offset(resultStart - expression.StartRow, 0, resultEnd - expression.EndRow, 0, true, true));
                }
            }
            else
            {
                CalcExternalRangeExpression expression2 = dataRange as CalcExternalRangeExpression;
                if (expression2 != null)
                {
                    int num4 = -1;
                    int num5 = -1;
                    SubCat(expression2.StartRow, expression2.EndRow, row, targetEnd, ref num4, ref num5);
                    if ((num4 > -1) && (num5 > -1))
                    {
                        return(expression2.Offset(num4 - expression2.StartRow, 0, num5 - expression2.EndRow, 0, true, true));
                    }
                }
            }
            return(null);
        }
Esempio n. 3
0
        static CalcExpression AddColumnRange(int column, int columnCount, CalcReferenceExpression dataRange)
        {
            CalcRangeExpression expression = dataRange as CalcRangeExpression;

            if (expression != null)
            {
                if (column > expression.EndColumn)
                {
                    return(expression);
                }
                if (column > expression.StartColumn)
                {
                    return(expression.Offset(0, 0, 0, columnCount, true, true));
                }
                return(expression.Offset(0, columnCount, true, true) as CalcRangeExpression);
            }
            CalcExternalRangeExpression expression2 = dataRange as CalcExternalRangeExpression;

            if (expression2 == null)
            {
                return(null);
            }
            if (column > expression2.EndColumn)
            {
                return(expression2);
            }
            if (column > expression2.StartColumn)
            {
                return(expression2.Offset(0, 0, 0, columnCount, true, true));
            }
            return(expression2.Offset(0, columnCount, true, true) as CalcExternalRangeExpression);
        }
Esempio n. 4
0
        public static string FormatCellRange(Worksheet worksheet, CellRange cellRange)
        {
            CalcReferenceExpression expressionFromCellRange = GetExpressionFromCellRange(worksheet, cellRange);
            List <CalcExpression>   expressions             = new List <CalcExpression> {
                expressionFromCellRange
            };

            return(FormulaUtility.BuildFormula(worksheet, expressions));
        }
Esempio n. 5
0
        private object EvaluateReference(CalcReferenceExpression expr, CalcEvaluatorContext context, bool acceptsReference)
        {
            if (object.ReferenceEquals(context, null))
            {
                return(CalcErrors.Value);
            }
            CalcIdentity id = expr.GetId(context.Row, context.Column);

            if (!acceptsReference && !context.ArrayFormulaMode)
            {
                return(context.GetValue(id));
            }
            return(context.GetReference(id));
        }
Esempio n. 6
0
        public static CellRange GetRangeFromExpression(CalcReferenceExpression reference)
        {
            int row         = 0;
            int column      = 0;
            int rowCount    = 0;
            int columnCount = 0;

            if (reference is CalcCellExpression)
            {
                CalcCellExpression expression = reference as CalcCellExpression;
                row         = expression.Row;
                column      = expression.Column;
                rowCount    = 1;
                columnCount = 1;
            }
            else if (reference is CalcRangeExpression)
            {
                CalcRangeExpression expression2 = reference as CalcRangeExpression;
                if (expression2.IsFullColumn)
                {
                    row         = -1;
                    column      = expression2.StartColumn;
                    rowCount    = -1;
                    columnCount = (expression2.EndColumn - expression2.StartColumn) + 1;
                }
                else if (expression2.IsFullRow)
                {
                    row         = expression2.StartRow;
                    column      = -1;
                    rowCount    = (expression2.EndRow - expression2.StartRow) + 1;
                    columnCount = -1;
                }
                else
                {
                    row         = expression2.StartRow;
                    column      = expression2.StartColumn;
                    rowCount    = (expression2.EndRow - expression2.StartRow) + 1;
                    columnCount = (expression2.EndColumn - expression2.StartColumn) + 1;
                }
            }
            else if (reference is CalcExternalCellExpression)
            {
                CalcExternalCellExpression expression3 = reference as CalcExternalCellExpression;
                row         = expression3.Row;
                column      = expression3.Column;
                rowCount    = 1;
                columnCount = 1;
            }
            else if (reference is CalcExternalRangeExpression)
            {
                CalcExternalRangeExpression expression4 = reference as CalcExternalRangeExpression;
                if (expression4.IsFullColumn)
                {
                    row         = -1;
                    column      = expression4.StartColumn;
                    rowCount    = -1;
                    columnCount = (expression4.EndColumn - expression4.StartColumn) + 1;
                }
                else if (expression4.IsFullRow)
                {
                    row         = expression4.StartRow;
                    column      = -1;
                    rowCount    = (expression4.EndRow - expression4.StartRow) + 1;
                    columnCount = -1;
                }
                else
                {
                    row         = expression4.StartRow;
                    column      = expression4.StartColumn;
                    rowCount    = (expression4.EndRow - expression4.StartRow) + 1;
                    columnCount = (expression4.EndColumn - expression4.StartColumn) + 1;
                }
            }
            return(new CellRange(row, column, rowCount, columnCount));
        }