public object Evaluate(Report rpt, Row row) { object v = null; if (row == null) return null; bool bSave=true; RowEnumerable re = this.GetDataScope(rpt, row, out bSave); if (re == null) return null; Row crow=null; bool bNext=false; foreach (Row r in re) { if (bNext) { crow = r; break; } if (r == row) bNext = true; } if (crow != null) v = _Expr.Evaluate(rpt, crow); return v; }
public int EvaluateInt32(Report rpt, Row row) { bool bSave=true; IEnumerable re = this.GetDataScope(rpt, row, out bSave); if (re == null) return int.MinValue; Row startrow=null; foreach (Row r in re) { startrow = r; // We just want the first row break; } int count; object currentValue = _Expr.Evaluate(rpt, row); int incr = currentValue == null? 0: 1; if (row == startrow) { // must be the start of a new group count = incr; } else { count = GetValue(rpt) + incr; } SetValue(rpt, count); return count; }
public int EvaluateInt32(Report rpt, Row row) { bool bSave=true; RowEnumerable re = this.GetDataScope(rpt, row, out bSave); if (re == null) return 0; int v = GetValue(rpt); if (v < 0) { object temp; int count = Math.Max(2, re.LastRow - re.FirstRow); Hashtable ht = new Hashtable(count); foreach (Row r in re) { temp = _Expr.Evaluate(rpt, r); if (temp != null) { object o = ht[temp]; // search for it if (o == null) // if not found; add it to the hash table { ht.Add(temp, temp); } } } v = ht.Count; if (bSave) SetValue(rpt, v); } return v; }
public void RunPage(Pages pgs, Row row) { // Start each row in the same location // e.g. if there are two embedded tables in cells they both start at same location Page savepg = pgs.CurrentPage; float savey = savepg.YOffset; Page maxpg = savepg; float maxy = savey; foreach (TableCell tc in _Items) { tc.RunPage(pgs, row); if (maxpg != pgs.CurrentPage) { // a page break if (maxpg.PageNumber < pgs.CurrentPage.PageNumber) { maxpg = pgs.CurrentPage; maxy = maxpg.YOffset; } } else if (maxy > pgs.CurrentPage.YOffset) { // maxy = maxy; TODO what was this meant to do } // restore the beginning start of the row pgs.CurrentPage = savepg; savepg.YOffset = savey; } pgs.CurrentPage = maxpg; savepg.YOffset = maxy; return ; }
public object Evaluate(Report rpt, Row row) { bool bSave=true; IEnumerable re = this.GetDataScope(rpt, row, out bSave); if (re == null) return null; Row startrow=null; foreach (Row r in re) { startrow = r; // We just want the first row break; } object current_value = _Expr.Evaluate(rpt, row); if (row == startrow) {} else { object v = GetValue(rpt); if (current_value == null) return v; else if (v == null) {} // use the current_value else if (Filter.ApplyCompare(_tc, v, current_value) < 0) {} // use the current_value else return v; } SetValue(rpt, current_value); return current_value; }
// public virtual object Evaluate(Report rpt, Row row) { if (row == null) return null; Field f; string field = _ArgExpr.EvaluateString(rpt, row); if (field == null) return null; f = _Fields[field] as Field; if (f == null) return null; object o; if (f.Value != null) o = f.Value.Evaluate(rpt, row); else o = row.Data[f.ColumnNumber]; if (o == DBNull.Value) return null; if (f.RunType == TypeCode.String && o is char) // work around; mono odbc driver confuses string and char o = Convert.ChangeType(o, TypeCode.String); return o; }
public double EvaluateDouble(Report rpt, Row row) { bool bSave=true; IEnumerable re = this.GetDataScope(rpt, row, out bSave); if (re == null) return double.NaN; ODouble v = GetValueDouble(rpt); if (v != null) return v.d; double sum=0; int count=0; double temp; foreach (Row r in re) { temp = _Expr.EvaluateDouble(rpt, r); if (temp.CompareTo(double.NaN) != 0) { sum += temp; count++; } } double result; if (count > 0) result = (sum/count); else result = double.NaN; if (bSave) SetValue(rpt, result); return result; }
public DynamicExpression(Report rpt, ReportLink p, string expr, Row row) { _Source=expr; _Expr = null; _rl = p; _Type = DoParse(rpt); }
public string EvaluateString(Report rpt, Row row) { if (rpt == null || rpt.UserID == null) return Environment.UserName; else return rpt.UserID; }
// Evaluate is for interpretation (and is relatively slow) public object Evaluate(Report rpt, Row row) { double d = EvaluateDouble(rpt, row); if (d.CompareTo(double.NaN) == 0) return null; return (object) d; }
public double EvaluateDouble(Report rpt, Row row) { bool bSave=true; IEnumerable re = this.GetDataScope(rpt, row, out bSave); if (re == null) return double.NaN; Row startrow=null; foreach (Row r in re) { startrow = r; // We just want the first row break; } double currentValue = _Expr.EvaluateDouble(rpt, row); WorkClass wc = GetValue(rpt); if (row == startrow) { // must be the start of a new group wc.Value = currentValue; wc.Count = 1; } else { wc.Value = ((double) wc.Value + currentValue); wc.Count++; } return (double) wc.Value / wc.Count; }
public string EvaluateString(Report rpt, Row row) { if (rpt == null || rpt.ClientLanguage == null) return CultureInfo.CurrentCulture.ThreeLetterISOLanguageName; else return rpt.ClientLanguage; }
public object Evaluate(Report rpt, Row row) { bool bSave=true; IEnumerable re = this.GetDataScope(rpt, row, out bSave); if (re == null) return null; object v = GetValue(rpt); if (v == null) { object min_value=null; object current_value; foreach (Row r in re) { current_value = _Expr.Evaluate(rpt, r); if (current_value == null) continue; else if (min_value == null) min_value = current_value; else if (Filter.ApplyCompare(_tc, min_value, current_value) > 0) min_value = current_value; } v = min_value; if (bSave) SetValue(rpt, v); } return v; }
public void Run(IPresent ip, Row row) { foreach (TableCell tc in _Items) { tc.Run(ip, row); } return ; }
public void Run(IPresent ip, Row row) { foreach (TableRow t in _Items) { t.Run(ip, row); } return; }
// public object Evaluate(Report rpt, Row row) { double di = _expr[0].EvaluateDouble(rpt, row); int i = (int) di; // force it to integer; we'll accept truncation if (i >= _expr.Length || i <= 0) return null; return _expr[i].Evaluate(rpt, row); }
public bool EvaluateBoolean(Report rpt, Row row) { object left = _lhs.Evaluate(rpt, row); object right = _rhs.Evaluate(rpt, row); if (Filter.ApplyCompare(_lhs.GetTypeCode(), left, right) <= 0) return true; else return false; }
public int EvaluateInt32(Report rpt, Row row) { bool bSave=true; RowEnumerable re = this.GetDataScope(rpt, row, out bSave); if (re == null) return 0; int count = re.LastRow - re.FirstRow + 1; return count; }
public bool Apply(Report rpt, Row datarow) { foreach (Filter f in _Items) { if (!f.FilterOperatorSingleRow) // have to handle Top/Bottom in ApplyFinalFilters return true; if (!f.Apply(rpt, datarow)) return false; } return true; }
// public virtual object Evaluate(Report rpt, Row row) { string o = _ArgExpr.EvaluateString(rpt, row); if (o == null) return null; ReportParameter rp = _Parameters[o] as ReportParameter; if (rp == null) return null; return rp.GetRuntimeValue(rpt); }
override public void RunPage(Pages pgs, Row row) { Report r = pgs.Report; bool bHidden = IsHidden(r, row); SetPagePositionBegin(pgs); PageLine pl = new PageLine(); SetPagePositionAndStyle(r, pl, row); if (!bHidden) pgs.CurrentPage.AddObject(pl); SetPagePositionEnd(pgs, pl.Y); }
// Evaluate is for interpretation (and is relatively slow) public object Evaluate(Report rpt, Row row) { bool result = _If.EvaluateBoolean(rpt, row); if (result) return _IfTrue.Evaluate(rpt, row); object o = _IfFalse.Evaluate(rpt, row); // We may need to convert IfFalse to same type as IfTrue if (_IfTrue.GetTypeCode() == _IfFalse.GetTypeCode()) return o; return Convert.ChangeType(o, _IfTrue.GetTypeCode()); }
public void RunPage(Pages pgs, Row row) { Page p = pgs.CurrentPage; if (p.YOffset + HeightOfRows(pgs, row) > pgs.BottomOfPage) { p = OwnerTable.RunPageNew(pgs, p); OwnerTable.RunPageHeader(pgs, row, false, null); } _TableRows.RunPage(pgs, row); return; }
public double EvaluateDouble(Report rpt, Row row) { if (row == null || this._Scope == null) return 0; Grouping g = this._Scope as Grouping; if (g == null || g.ParentGroup == null) return 0; // GroupEntry ge = row.R.CurrentGroups[g.Index]; // current group entry return row.Level; }
public ChartBase(Report r, Row row, Chart c, MatrixCellEntry[,] m, Expression showTooltips, Expression showTooltipsX,Expression _ToolTipYFormat, Expression _ToolTipXFormat) { _ChartDefn = c; _row = row; _DataDefn = m; _bm = null; int width = _ChartDefn.WidthCalc(r, null); int height = RSize.PixelsFromPoints(_ChartDefn.HeightOrOwnerHeight); Layout = new ChartLayout(width, height); _SeriesBrush = null; _SeriesMarker = null; _showToolTips = showTooltips.EvaluateBoolean(r, row); _showToolTipsX = showTooltipsX.EvaluateBoolean(r, row); _tooltipYFormat = _ToolTipYFormat.EvaluateString(r, row); _tooltipXFormat = _ToolTipXFormat.EvaluateString(r, row); }
// Evaluate is for interpretation (and is relatively slow) public object Evaluate(Report rpt, Row row) { // get the results object[] argResults = new object[_Args.Length]; int i=0; bool bNull = false; foreach(IExpr a in _Args) { argResults[i] = a.Evaluate(rpt, row); if (argResults[i] == null) bNull = true; i++; } Type[] argTypes; if (bNull) { // Need to put fake values in that match the types object[] tempResults = new object[argResults.Length]; for (int ix = 0; ix < argResults.Length; ix++) { tempResults[ix] = argResults[ix] == null? XmlUtil.GetConstFromTypeCode(_Args[ix].GetTypeCode()): argResults[ix]; } argTypes = Type.GetTypeArray(tempResults); } else argTypes = Type.GetTypeArray(argResults); // We can definitely optimize this by caching some info TODO // Get ready to call the function object returnVal; Type theClassType= Type.GetType(_Cls, true, true); MethodInfo mInfo = XmlUtil.GetMethod(theClassType, _Func, argTypes); if (mInfo == null) { throw new Exception(string.Format("{0} method not found in class {1}", _Func, _Cls)); } returnVal = mInfo.Invoke(theClassType, argResults); return returnVal; }
// Evaluate is for interpretation (and is relatively slow) public override object Evaluate(Report rpt, Row row) { string v = base.EvaluateString(rpt, row); if (p.ValidValues == null) return v; string[] displayValues = p.ValidValues.DisplayValues(rpt); object[] dataValues = p.ValidValues.DataValues(rpt); for (int i=0; i < dataValues.Length; i++) { if (dataValues[i].ToString() == v) return displayValues[i]; } return v; }
// Evaluate is for interpretation (and is relatively slow) public object Evaluate(Report rpt, Row row) { bool result; for (int i=0; i < _expr.Length; i = i+2) { result = _expr[i].EvaluateBoolean(rpt, row); if (result) { object o = _expr[i+1].Evaluate(rpt, row); // We may need to convert to same type as first type if (i == 0 || _tc == _expr[i+1].GetTypeCode()) // first typecode will always match return o; return Convert.ChangeType(o, _tc); } } return null; }
// public virtual object Evaluate(Report rpt, Row row) { if (rpt == null) return null; string u = _ArgExpr.EvaluateString(rpt, row); if (u == null) return null; switch (u.ToLower()) { case "userid": return rpt.UserID; case "language": return rpt.ClientLanguage == null? CultureInfo.CurrentCulture.ThreeLetterISOLanguageName: rpt.ClientLanguage; default: return null; } }
public double EvaluateDouble(Report rpt, Row row) { bool bSave=true; IEnumerable re = this.GetDataScope(rpt, row, out bSave); if (re == null) return double.NaN; ODouble od = GetValue(rpt); if (od != null) return od.d; double sum=0; double sum2=0; int count=0; double temp; foreach (Row r in re) { temp = _Expr.EvaluateDouble(rpt, r); if (temp.CompareTo(double.NaN) != 0) { sum += temp; sum2 += (temp*temp); count++; } } double result; if (count > 1) { result = Math.Sqrt((count * sum2 - sum*sum) / (count * (count-1))); } else result = double.NaN; if (bSave) SetValue(rpt, result); return result; }
public int EvaluateInt32(Report rpt, Row row) { decimal result = EvaluateDecimal(rpt, row); return(Convert.ToInt32(result)); }
public string EvaluateString(Report rpt, Row row) { decimal result = EvaluateDecimal(rpt, row); return(result.ToString()); }
public DateTime EvaluateDateTime(Report rpt, Row row) { decimal result = EvaluateDecimal(rpt, row); return(Convert.ToDateTime(result)); }
public bool EvaluateBoolean(Report rpt, Row row) { decimal result = EvaluateDecimal(rpt, row); return(Convert.ToBoolean(result)); }
// Evaluate is for interpretation (and is relatively slow) public object Evaluate(Report rpt, Row row) { return(EvaluateDecimal(rpt, row)); }
public double EvaluateDouble(Report rpt, Row row) { decimal result = EvaluateDecimal(rpt, row); return(Convert.ToDouble(result)); }