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));
}
