예제 #1
0
        internal string RunText(Report rpt, Row row)
        {
            object o = _Value.Evaluate(rpt, row);

            // AJM 15082008: Suppress NaN from appearing in a textbox
            if (o is double)
            {
                if (Double.IsNaN((double)o))
                {
                    o = null;
                }
            }
            string t = Style.GetFormatedString(rpt, this.Style, row, o, _Value.GetTypeCode());

            if (IsHtml(rpt, row) && t != null && t.Contains("<expr>"))
            {
                string[]      parts = HTMLEXPR.Split(t);
                StringBuilder sb    = new StringBuilder(t.Length);
                foreach (string s in parts)
                {
                    if (s.StartsWith("<expr>") && s.EndsWith("</expr>"))
                    {
                        string            expr = s.Substring(6, s.Length - 13);
                        DynamicExpression de   = new DynamicExpression(rpt, this, expr, row);
                        sb.Append(de.Evaluate(rpt, row));
                    }
                    else
                    {
                        sb.Append(s);
                    }
                }
                t = sb.ToString();
            }
            return(t);
        }
예제 #2
0
        // Apply the filters to a row to determine if row is valid
        internal bool Apply(Report rpt, Row datarow)
        {
            object   left  = _FilterExpression.Evaluate(rpt, datarow);
            TypeCode tc    = _FilterExpression.GetTypeCode();
            object   right = ((FilterValue)(_FilterValues.Items[0])).Expression.Evaluate(rpt, datarow);

            switch (_FilterOperator)
            {
            case FilterOperatorEnum.Equal:
                return(ApplyCompare(tc, left, right) == 0? true: false);

            case FilterOperatorEnum.Like:                       // TODO - this is really regex (not like)
                if (left == null || right == null)
                {
                    return(false);
                }
                string s1 = Convert.ToString(left);
                string s2 = Convert.ToString(right);
                return(Regex.IsMatch(s1, s2));

            case FilterOperatorEnum.NotEqual:
                return(ApplyCompare(tc, left, right) == 0? false: true);

            case FilterOperatorEnum.GreaterThan:
                return(ApplyCompare(tc, left, right) > 0? true: false);

            case FilterOperatorEnum.GreaterThanOrEqual:
                return(ApplyCompare(tc, left, right) >= 0? true: false);

            case FilterOperatorEnum.LessThan:
                return(ApplyCompare(tc, left, right) < 0? true: false);

            case FilterOperatorEnum.LessThanOrEqual:
                return(ApplyCompare(tc, left, right) <= 0? true: false);

            case FilterOperatorEnum.TopN:
            case FilterOperatorEnum.BottomN:
            case FilterOperatorEnum.TopPercent:
            case FilterOperatorEnum.BottomPercent:
                return(true);                                   // This is handled elsewhere

            case FilterOperatorEnum.In:
                foreach (FilterValue fv in _FilterValues.Items)
                {
                    right = fv.Expression.Evaluate(rpt, datarow);
                    if (right is ArrayList) // this can only happen with MultiValue parameters
                    {                       // check each object in the array
                        foreach (object v in right as ArrayList)
                        {
                            if (ApplyCompare(tc, left, v) == 0)
                            {
                                return(true);
                            }
                        }
                    }
                    else if (ApplyCompare(tc, left, right) == 0)
                    {
                        return(true);
                    }
                }
                return(false);

            case FilterOperatorEnum.Between:
                if (ApplyCompare(tc, left, right) < 0)
                {
                    return(false);
                }
                right = ((FilterValue)(_FilterValues.Items[1])).Expression.Evaluate(rpt, datarow);
                return(ApplyCompare(tc, left, right) <= 0? true: false);

            default:
                return(true);
            }
        }