List<TableGroup> _Items; // list of TableGroup entries
internal TableGroups(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
TableGroup tg;
_Items = new List<TableGroup>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "TableGroup":
tg = new TableGroup(r, this, xNodeLoop);
break;
default:
tg=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown TableGroups element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (tg != null)
_Items.Add(tg);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For TableGroups at least one TableGroup is required.");
else
_Items.TrimExcess();
}
List<ParameterValue> _Items; // list of ParameterValue
#endregion Fields
#region Constructors
internal ParameterValues(ReportDefn r, ReportLink p, XmlNode xNode)
: base(r, p)
{
ParameterValue pv;
_Items = new List<ParameterValue>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "ParameterValue":
pv = new ParameterValue(r, this, xNodeLoop);
break;
default:
pv=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown ParameterValues element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (pv != null)
_Items.Add(pv);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For ParameterValues at least one ParameterValue is required.");
else
_Items.TrimExcess();
}
List<TableCell> _Items; // list of TableCell
internal TableCells(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
TableCell tc;
_Items = new List<TableCell>();
// Loop thru all the child nodes
int colIndex=0; // keep track of the column numbers
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "TableCell":
tc = new TableCell(r, this, xNodeLoop, colIndex);
colIndex += tc.ColSpan;
break;
default:
tc=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown TableCells element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (tc != null)
_Items.Add(tc);
}
if (_Items.Count > 0)
_Items.TrimExcess();
}
List<GroupExpression> _Items; // list of GroupExpression
internal GroupExpressions(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
GroupExpression g;
_Items = new List<GroupExpression>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "GroupExpression":
g = new GroupExpression(r, this, xNodeLoop);
break;
default:
g=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown GroupExpressions element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (g != null)
_Items.Add(g);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "GroupExpressions require at least one GroupExpression be defined.");
else
_Items.TrimExcess();
}
List<DataPoint> _Items; // list of datapoint
internal DataPoints(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
DataPoint dp;
_Items = new List<DataPoint>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "DataPoint":
dp = new DataPoint(r, this, xNodeLoop);
break;
default:
dp=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown DataPoints element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (dp != null)
_Items.Add(dp);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For DataPoints at least one DataPoint is required.");
else
_Items.TrimExcess();
}
private string BuildTable()
{
StringBuilder sb = new StringBuilder();
float width = TableWidth();
sb.AppendFormat("<table style=\"table-layout:fixed;width:{0}pt;border-style:none;border-collapse:collapse;\">", width);
// Define the columns
sb.Append("<colgroup>");
List<ReportItem> riSort = new List<ReportItem>(_ris.Items);
riSort.Sort(CompareRIsByX);
// float last_offset=0;
float offset;
float pt;
for (int i = 0; i < riSort.Count; i++)
{
pt = riSort[i].LeftCalc(_rpt);
sb.AppendFormat("<col style=\"width:{0}pts;\">", pt);
offset = pt + riSort[i].WidthOrOwnerWidth(_rpt);
// if (last_offset < offset)
}
sb.Append("</colgroup>");
// Define the rows
riSort.Sort(CompareRIsByY);
sb.Append("</table>");
return sb.ToString();
}
string _key; // key for cache when scope is dataset we can cache the result
/// <summary>
/// Aggregate function: Stdevp = (sqrt(n sum(square(x)) - square((sum(x))) / n*n)
/// Stdev assumes values are a sample of the population of data. If the data
/// is the entire representation then use Stdevp.
///
/// Return type is decimal for decimal expressions and double for all
/// other expressions.
/// </summary>
public FunctionAggrStdevp(List<ICacheData> dataCache, IExpr e, object scp)
: base(e, scp)
{
_key = "aggrstdevp" + Interlocked.Increment(ref Parser.Counter).ToString();
dataCache.Add(this);
}
internal ColumnGroupings(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
ColumnGrouping g;
_Items = new List<ColumnGrouping>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "ColumnGrouping":
g = new ColumnGrouping(r, this, xNodeLoop);
break;
default:
g=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown ColumnGroupings element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (g != null)
_Items.Add(g);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For ColumnGroups at least one ColumnGrouping is required.");
else
{
_Items.TrimExcess();
_StaticCount = GetStaticCount();
}
}
List<Textbox> _GrowList; // list of TextBox's that need to be checked for growth
internal TableRow(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
_TableCells=null;
_Height=null;
_Visibility=null;
_CanGrow = false;
_GrowList = null;
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "TableCells":
_TableCells = new TableCells(r, this, xNodeLoop);
break;
case "Height":
_Height = new RSize(r, xNodeLoop);
break;
case "Visibility":
_Visibility = new Visibility(r, this, xNodeLoop);
break;
default:
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown TableRow element '" + xNodeLoop.Name + "' ignored.");
break;
}
}
if (_TableCells == null)
OwnerReport.rl.LogError(8, "TableRow requires the TableCells element.");
if (_Height == null)
OwnerReport.rl.LogError(8, "TableRow requires the Height element.");
}
float _yOffset; // current y offset; top margin, page header, other details, ...
#endregion Fields
#region Constructors
public Page(int page)
{
_pageno = page;
_items = new List<PageItem>();
_emptyItems = 0;
_needSort = false;
}
List<CodeModule> _Items; // list of code module
#endregion Fields
#region Constructors
internal CodeModules(ReportDefn r, ReportLink p, XmlNode xNode)
: base(r, p)
{
_Items = new List<CodeModule>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
if (xNodeLoop.Name == "CodeModule")
{
CodeModule cm = new CodeModule(r, this, xNodeLoop);
_Items.Add(cm);
}
else
{
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown CodeModules element '" + xNodeLoop.Name + "' ignored.");
}
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For CodeModules at least one CodeModule is required.");
else
_Items.TrimExcess();
}
List<GroupEntry> _NestedGroup; // group one hierarchy below
internal GroupEntry(Grouping g, Sorting s, int start)
{
_Group = g;
_Sort = s;
_StartRow = start;
_EndRow = -1;
_NestedGroup = new List<GroupEntry>();
// Check to see if grouping and sorting are the same
if (g == null || s == null)
return; // nothing to check if either is null
if (s.Items.Count != g.GroupExpressions.Items.Count)
return;
for (int i = 0; i < s.Items.Count; i++)
{
SortBy sb = s.Items[i] as SortBy;
if (sb.Direction == SortDirectionEnum.Descending)
return; // TODO we could optimize this
FunctionField ff = sb.SortExpression.Expr as FunctionField;
if (ff == null || ff.GetTypeCode() != TypeCode.String)
return;
GroupExpression ge = g.GroupExpressions.Items[i] as GroupExpression;
FunctionField ff2 = ge.Expression.Expr as FunctionField;
if (ff2 == null || ff.Fld != ff2.Fld)
return;
}
_Sort = null; // we won't need to sort since the groupby will handle it correctly
}
List<DrillthroughParameter> _Items; // list of report items
internal DrillthroughParameters(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
DrillthroughParameter d;
_Items = new List<DrillthroughParameter>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "Parameter":
d = new DrillthroughParameter(r, this, xNodeLoop);
break;
default:
d=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown Parameters element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (d != null)
_Items.Add(d);
}
if (_Items.Count > 0)
_Items.TrimExcess();
}
public StreamGen(string directory, string relativeDirectory, string ext)
{
_Directory = directory;
_RelativeDirectory = relativeDirectory;
if (_Directory[_Directory.Length-1] == Path.DirectorySeparatorChar ||
_Directory[_Directory.Length-1] == Path.AltDirectorySeparatorChar)
_Directory = _Directory.Substring(0, _Directory.Length-1);
// ensure we have a separator before and after the relative directory name
if (_RelativeDirectory == null)
_RelativeDirectory = Path.DirectorySeparatorChar.ToString();
if (!(_RelativeDirectory[0] == Path.DirectorySeparatorChar ||
_RelativeDirectory[0] == Path.AltDirectorySeparatorChar))
_RelativeDirectory = Path.DirectorySeparatorChar + _RelativeDirectory;
if (!(_RelativeDirectory[_RelativeDirectory.Length-1] == Path.DirectorySeparatorChar ||
_RelativeDirectory[_RelativeDirectory.Length-1] == Path.AltDirectorySeparatorChar))
_RelativeDirectory = _RelativeDirectory + Path.DirectorySeparatorChar;
_FileList = new List<string>();
string relativeName;
_io = GetIOStream(out relativeName, ext);
_FileName = _Directory + relativeName;
_rand = null;
}
List<ChartSeries> _Items; // list of chart series
internal ChartData(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
ChartSeries cs;
_Items = new List<ChartSeries>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "ChartSeries":
cs = new ChartSeries(r, this, xNodeLoop);
break;
default:
cs=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown ChartData element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (cs != null)
_Items.Add(cs);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For ChartData at least one ChartSeries is required.");
else
_Items.TrimExcess();
}
List<StaticColumn> _Items; // list of StaticColumn
internal StaticColumns(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
StaticColumn sc;
_Items = new List<StaticColumn>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "StaticColumn":
sc = new StaticColumn(r, this, xNodeLoop);
break;
default:
sc=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown StaticColumns element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (sc != null)
_Items.Add(sc);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For StaticColumns at least one StaticColumn is required.");
else
_Items.TrimExcess();
}
List<SortBy> _Items; // list of SortBy
#endregion Fields
#region Constructors
internal Sorting(ReportDefn r, ReportLink p, XmlNode xNode)
: base(r, p)
{
SortBy s;
_Items = new List<SortBy>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "SortBy":
s = new SortBy(r, this, xNodeLoop);
break;
default:
s=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown Sorting element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (s != null)
_Items.Add(s);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "Sorting requires at least one SortBy be defined.");
else
_Items.TrimExcess();
}
List<SeriesGrouping> _Items; // list of SeriesGrouping
internal SeriesGroupings(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
SeriesGrouping sg;
_Items = new List<SeriesGrouping>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "SeriesGrouping":
sg = new SeriesGrouping(r, this, xNodeLoop);
break;
default:
sg=null; // don't know what this is
break;
}
if (sg != null)
_Items.Add(sg);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For SeriesGroupings at least one SeriesGrouping is required.");
else
_Items.TrimExcess();
}
List<MatrixRow> _Items; // list of MatrixRow
#endregion Fields
#region Constructors
internal MatrixRows(ReportDefn r, ReportLink p, XmlNode xNode)
: base(r, p)
{
MatrixRow m;
_Items = new List<MatrixRow>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "MatrixRow":
m = new MatrixRow(r, this, xNodeLoop);
break;
default:
m=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown MatrixRows element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (m != null)
_Items.Add(m);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For MatrixRows at least one MatrixRow is required.");
else
_Items.TrimExcess();
}
string _key; // key used for caching value
#endregion Fields
#region Constructors
/// <summary>
/// Aggregate function: CountDistinct
///
/// Return type is double
/// </summary>
public FunctionAggrCountDistinct(List<ICacheData> dataCache, IExpr e, object scp)
: base(e, scp)
{
_key = "countdistinct" + Interlocked.Increment(ref Parser.Counter).ToString();
dataCache.Add(this);
}
bool _ContainsArray; // true if any of the parameters is an array reference
internal QueryParameters(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
_ContainsArray = false;
QueryParameter q;
_Items = new List<QueryParameter>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "QueryParameter":
q = new QueryParameter(r, this, xNodeLoop);
break;
default:
q=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown QueryParameters element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (q != null)
_Items.Add(q);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "For QueryParameters at least one QueryParameter is required.");
else
_Items.TrimExcess();
}
List<Filter> _Items; // list of Filter
internal Filters(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
{
Filter f;
_Items = new List<Filter>();
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "Filter":
f = new Filter(r, this, xNodeLoop);
break;
default:
f=null; // don't know what this is
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown Filters element '" + xNodeLoop.Name + "' ignored.");
break;
}
if (f != null)
_Items.Add(f);
}
if (_Items.Count == 0)
OwnerReport.rl.LogError(8, "Filters require at least one Filter be defined.");
else
_Items.TrimExcess();
}
/// <summary>
/// Initializes a new instance of the Lexer class with the specified
/// TextReader to lex.
/// </summary>
/// <param name="source">A TextReader to lex.</param>
internal PageTextHtmlLexer(string html)
{
// token queue
tokens = new List<string>();
// read the file contents
reader = new CharReader(html);
}
internal DialogValidValues(List<ParameterValueItem> list)
{
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
// Initialize form using the style node values
InitValues(list);
}
float _PageWidth; // default width for all pages
public Pages(Report r)
{
_report = r;
_pages = new List<Page>(); // array of Page objects
_bm = Bitmap.CreateBitmap(10, 10, System.Drawing.Imaging.PixelFormat.Format16bppRgb565); // create a small bitmap to base our graphics
_g = Graphics.FromImage(_bm);
}
float _PageWidth; // default width for all pages
public Pages(Report r)
{
_report = r;
_pages = new List<Page>(); // array of Page objects
_bm = new Bitmap(10, 10); // create a small bitmap to base our graphics
_g = Graphics.FromImage(_bm);
}
internal ReportLog(ReportLog rl)
{
if (rl != null && rl.ErrorItems != null)
{
_MaxSeverity = rl.MaxSeverity;
_ErrorItems = new List<string>(rl.ErrorItems);
}
}
internal DrawEllipse(Single Xin, Single Yin, Single WidthIn, Single HeightIn, System.Collections.Hashtable ObjectTableIn)
{
X = Xin;
Y = Yin;
Width = WidthIn;
Height = HeightIn;
items = new List<PageItem>();
}
string _key; // key for caching
/// <summary>
/// Aggregate function: Max returns the highest value
/// Return type is same as input expression
/// </summary>
public FunctionAggrMax(List<ICacheData> dataCache, IExpr e, object scp)
: base(e, scp)
{
_key = "aggrmax" + Interlocked.Increment(ref Parser.Counter).ToString();
// Determine the result
_tc = e.GetTypeCode();
dataCache.Add(this);
}
internal FillPolygon(Single Xin, Single Yin, Single WidthIn, Single HeightIn, System.Collections.Hashtable ObjectTableIn)
{
X = Xin;
Y = Yin;
Width = WidthIn;
Height = HeightIn;
ObjectTable = ObjectTableIn;
items = new List<PageItem>();
}