List<ChartSeries> _Items; // list of chart series

        #endregion Fields

        #region Constructors

        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<TableCell> _Items; // list of TableCell

        #endregion Fields

        #region Constructors

        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();
        }
        string _ToggleItem; // The name of the textbox used to

        #endregion Fields

        #region Constructors

        // hide/unhide this report item. Clicking on
        //an instance of the ToggleItem will toggle
        //the hidden state of every corresponding
        //instance of this item. If the Toggle item
        //becomes hidden, this item should become
        //hidden.
        //Must be a textbox in the same grouping
        //scope as this item or in any containing (ancestor) grouping scope
        //If omitted, no item will toggle the hidden
        //state of this item.
        //Not allowed on and cannot refer to report
        //items contained in a page header or
        //footer.
        //Cannot refer to a report item contained
        //within the current report item unless
        //current grouping scope has a Parent.
        internal Visibility(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _Hidden=null;
            _ToggleItem=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "Hidden":
                        _Hidden = new Expression(r, this, xNodeLoop, ExpressionType.Boolean);
                        break;
                    case "ToggleItem":
                        _ToggleItem = xNodeLoop.InnerText;
                        break;
                    default:
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown Visibility element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
            }
        }
        List<QueryParameter> _Items; // list of QueryParameter

        #endregion Fields

        #region Constructors

        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();
        }
        RSize _Width; // Width of the row header

        #endregion Fields

        #region Constructors

        internal RowGrouping(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _Width=null;
            _DynamicRows=null;
            _StaticRows=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "Width":
                        _Width = new RSize(r, xNodeLoop);
                        break;
                    case "DynamicRows":
                        _DynamicRows = new DynamicRows(r, this, xNodeLoop);
                        break;
                    case "StaticRows":
                        _StaticRows = new StaticRows(r, this, xNodeLoop);
                        break;
                    default:
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown RowGrouping element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
            }
            if (_Width == null)
                OwnerReport.rl.LogError(8, "RowGrouping requires the Width element.");
        }
        MatrixCells _MatrixCells; // The set of cells in a row in the detail section of the Matrix.

        #endregion Fields

        #region Constructors

        internal MatrixRow(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _Height=null;
            _MatrixCells=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "Height":
                        _Height = new RSize(r, xNodeLoop);
                        break;
                    case "MatrixCells":
                        _MatrixCells = new MatrixCells(r, this, xNodeLoop);
                        break;
                    default:
                        break;
                }
            }
            if (_MatrixCells == null)
                OwnerReport.rl.LogError(8, "MatrixRow requires the MatrixCells element.");
        }
        List<Filter> _Items; // list of Filter

        #endregion Fields

        #region Constructors

        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();
        }
        StaticCategories _StaticCategories; // Category headings for this grouping

        #endregion Fields

        #region Constructors

        internal CategoryGrouping(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _DynamicCategories=null;
            _StaticCategories=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "DynamicCategories":
                        _DynamicCategories = new DynamicCategories(r, this, xNodeLoop);
                        break;
                    case "StaticCategories":
                        _StaticCategories = new StaticCategories(r, this, xNodeLoop);
                        break;
                    default:
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown CategoryGrouping element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
            }
            if ((_DynamicCategories == null && _StaticCategories == null) ||
                (_DynamicCategories != null && _StaticCategories != null))
                OwnerReport.rl.LogError(8, "CategoryGrouping requires either DynamicCategories element or StaticCategories element, but not both.");
        }
        Sorting _Sorting; // The expressions to sort the data by

        #endregion Fields

        #region Constructors

        internal DynamicCategories(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _Grouping=null;
            _Sorting=null;
            _Label=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "Grouping":
                        _Grouping = new Grouping(r, this, xNodeLoop);
                        break;
                    case "Sorting":
                        _Sorting = new Sorting(r, this, xNodeLoop);
                        break;
                    case "Label":
                        _Label = new Expression(r, this, xNodeLoop, ExpressionType.Variant);
                        break;
                    default:
                        break;
                }
            }
            if (_Grouping == null)
                OwnerReport.rl.LogError(8, "DynamicCategories requires the Grouping element.");
        }
        StaticColumns _StaticColumns; // Static column headings for this grouping

        #endregion Fields

        #region Constructors

        internal ColumnGrouping(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _Height=null;
            _DynamicColumns=null;
            _StaticColumns=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "Height":
                        _Height = new RSize(r, xNodeLoop);
                        break;
                    case "DynamicColumns":
                        _DynamicColumns = new DynamicColumns(r, this, xNodeLoop);
                        break;
                    case "StaticColumns":
                        _StaticColumns = new StaticColumns(r, this, xNodeLoop);
                        break;
                    default:
                        break;
                }
            }
            if (_Height == null)
                OwnerReport.rl.LogError(8, "ColumnGrouping requires the Height element to be specified.");

            if ((_DynamicColumns != null && _StaticColumns != null) ||
                (_DynamicColumns == null && _StaticColumns == null))
                OwnerReport.rl.LogError(8, "ColumnGrouping requires either the DynamicColumns element or StaticColumns element but not both.");
        }
        Style _Style; // Line style properties for the gridlines and tickmarks

        #endregion Fields

        #region Constructors

        internal ChartGridLines(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _ShowGridLines=true;
            _Style=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "ShowGridLines":
                        _ShowGridLines = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                        break;
                    case "Style":
                        _Style = new Style(r, this, xNodeLoop);
                        break;
                    default:	// TODO
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown ChartGridLines element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
            }
        }
Exemple #12
0
        MarkerTypeEnum _Type; // Defines the marker type for values. Default: none

        #endregion Fields

        #region Constructors

        //  properties for the marker(s).
        internal Marker(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _Type=MarkerTypeEnum.None;
            _Size=null;
            _Style=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "Type":
                        _Type = MarkerType.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                        break;
                    case "Size":
                        _Size = new RSize(r, xNodeLoop);
                        break;
                    case "Style":
                        _Style = new Style(r, this, xNodeLoop);
                        break;
                    default:
                        break;
                }
            }
        }
        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();
        }
Exemple #14
0
        Expression _Hyperlink; // (URL)An expression that evaluates to the URL of the hyperlink

        #endregion Fields

        #region Constructors

        //An expression that evaluates to the ID of a
        //bookmark within the report to go to when this
        //report item is clicked on.
        //(If no bookmark with this ID is found, the link
        //will not be included in the report. If the
        //bookmark is hidden, the link will go to the start
        //of the page the bookmark is on. If multiple
        //bookmarks with this ID are found, the link will
        //go to the first one)
        // Constructor
        internal Action(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _Hyperlink = null;
            _Drillthrough = null;
            _BookmarkLink = null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "Hyperlink":
                        _Hyperlink = new Expression(r, this, xNodeLoop, ExpressionType.URL);
                        break;
                    case "Drillthrough":
                        _Drillthrough = new Drillthrough(r, this, xNodeLoop);
                        break;
                    case "BookmarkLink":
                        _BookmarkLink = new Expression(r, this, xNodeLoop, ExpressionType.String);
                        break;
                    default:
                        break;
                }
            }
        }
        List<GroupExpression> _Items; // list of GroupExpression

        #endregion Fields

        #region Constructors

        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();
        }
        string _ReportName; // URL The path of the drillthrough report. Paths may be

        #endregion Fields

        #region Constructors

        internal Drillthrough(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _ReportName=null;
            _DrillthroughParameters=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "ReportName":
                        _ReportName = xNodeLoop.InnerText;
                        break;
                    case "Parameters":
                        _DrillthroughParameters = new DrillthroughParameters(r, this, xNodeLoop);
                        break;
                    default:
                        break;
                }
            }
            if (_ReportName == null)
                OwnerReport.rl.LogError(8, "Drillthrough requires the ReportName element.");
        }
        internal Rectangle(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r,p,xNode)
        {
            _ReportItems=null;
            _PageBreakAtStart=false;
            _PageBreakAtEnd=false;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "ReportItems":
                        _ReportItems = new ReportItems(r, this, xNodeLoop);
                        break;
                    case "PageBreakAtStart":
                        _PageBreakAtStart = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                        break;
                    case "PageBreakAtEnd":
                        _PageBreakAtEnd = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                        break;
                    default:
                        if (ReportItemElement(xNodeLoop))	// try at ReportItem level
                            break;
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown Rectangle element " + xNodeLoop.Name + " ignored.");
                        break;
                }
            }
        }
        ReportItems _ReportItems; // Report items contained within the bounds of the rectangle.

        #endregion Fields

        #region Constructors

        // constructor that doesn't process syntax
        internal Rectangle(ReportDefn r, ReportLink p, XmlNode xNode, bool bNoLoop)
            : base(r,p,xNode)
        {
            _ReportItems=null;
            _PageBreakAtStart=false;
            _PageBreakAtEnd=false;
        }
        List<SeriesGrouping> _Items; // list of SeriesGrouping

        #endregion Fields

        #region Constructors

        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();
        }
Exemple #20
0
        TableRows _TableRows; // The footer rows for the table or group

        #endregion Fields

        #region Constructors

        // each page that the table (or group) is displayed
        internal Footer(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _TableRows=null;
            _RepeatOnNewPage=false;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "TableRows":
                        _TableRows = new TableRows(r, this, xNodeLoop);
                        break;
                    case "RepeatOnNewPage":
                        _RepeatOnNewPage = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                        break;
                    default:
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown Footer element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
            }
            if (_TableRows == null)
                OwnerReport.rl.LogError(8, "TableRows element is required with a Footer but not specified.");
        }
 internal RowGroupings(ReportDefn r, ReportLink p, XmlNode xNode)
     : base(r, p)
 {
     RowGrouping g;
     _Items = new List<RowGrouping>();
     // Loop thru all the child nodes
     foreach(XmlNode xNodeLoop in xNode.ChildNodes)
     {
         if (xNodeLoop.NodeType != XmlNodeType.Element)
             continue;
         switch (xNodeLoop.Name)
         {
             case "RowGrouping":
                 g = new RowGrouping(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 RowGroupings element '" + xNodeLoop.Name + "' ignored.");
                 break;
         }
         if (g != null)
             _Items.Add(g);
     }
     if (_Items.Count == 0)
         OwnerReport.rl.LogError(8, "For RowGroupings at least one RowGrouping is required.");
     else
     {
         _Items.TrimExcess();
         _StaticCount = GetStaticCount();
     }
 }
Exemple #22
0
        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<SubreportParameter> _Items; // list of SubreportParameter

        #endregion Fields

        #region Constructors

        internal SubReportParameters(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            SubreportParameter rp;
            _Items = new List<SubreportParameter>();
            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "Parameter":
                        rp = new SubreportParameter(r, this, xNodeLoop);
                        break;
                    default:
                        rp=null;		// don't know what this is
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown SubreportParameters element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
                if (rp != null)
                    _Items.Add(rp);
            }
            if (_Items.Count > 0)
                _Items.TrimExcess();
        }
        Expression _Top; //(Size) Width of the top border. Max: 20 pt Min: 0.25 pt

        #endregion Fields

        #region Constructors

        internal StyleBorderWidth(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _Default=null;
            _Left=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "Default":
                        _Default = new Expression(r, this, xNodeLoop, ExpressionType.ReportUnit);
                        break;
                    case "Left":
                        _Left = new Expression(r, this, xNodeLoop, ExpressionType.ReportUnit);
                        break;
                    case "Right":
                        _Right = new Expression(r, this, xNodeLoop, ExpressionType.ReportUnit);
                        break;
                    case "Top":
                        _Top = new Expression(r, this, xNodeLoop, ExpressionType.ReportUnit);
                        break;
                    case "Bottom":
                        _Bottom = new Expression(r, this, xNodeLoop, ExpressionType.ReportUnit);
                        break;
                    default:
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown BorderWidth element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
            }
        }
        List<DataValue> _Items; // list of DataValue

        #endregion Fields

        #region Constructors

        internal DataValues(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            DataValue dv;
            _Items = new List<DataValue>();
            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "DataValue":
                        dv = new DataValue(r, this, xNodeLoop);
                        break;
                    default:
                        dv=null;		// don't know what this is
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown DataValues element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
                if (dv != null)
                    _Items.Add(dv);
            }
            if (_Items.Count == 0)
                OwnerReport.rl.LogError(8, "For DataValues at least one DataValue is required.");
            else
                _Items.TrimExcess();
        }
        List<StaticMember> _Items; // list of StaticMember

        #endregion Fields

        #region Constructors

        internal StaticCategories(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            StaticMember sm;
            _Items = new List<StaticMember>();
            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "StaticMember":
                        sm = new StaticMember(r, this, xNodeLoop);
                        break;
                    default:
                        sm=null;		// don't know what this is
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown StaticCategories element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
                if (sm != null)
                    _Items.Add(sm);
            }
            if (_Items.Count == 0)
                OwnerReport.rl.LogError(8, "For StaticCategories at least one StaticMember is required.");
            else
                _Items.TrimExcess();
        }
        List<TableGroup> _Items; // list of TableGroup entries

        #endregion Fields

        #region Constructors

        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();
        }
        Style _Style; // border and background properties for series legend itmes and data points

        #endregion Fields

        #region Constructors

        //   when dynamic exprs are evaluated per group instance
        internal SeriesGrouping(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _DynamicSeries=null;
            _StaticSeries=null;
            _Style=null;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "DynamicSeries":
                        _DynamicSeries = new DynamicSeries(r, this, xNodeLoop);
                        break;
                    case "StaticSeries":
                        _StaticSeries = new StaticSeries(r, this, xNodeLoop);
                        break;
                    case "Style":
                        _Style = new Style(OwnerReport, this, xNodeLoop);
                        OwnerReport.rl.LogError(4, "Style element in SeriesGrouping is currently ignored."); // TODO
                        break;
                    default:
                        // don't know this element - log it
                        OwnerReport.rl.LogError(4, "Unknown SeriesGrouping element '" + xNodeLoop.Name + "' ignored.");
                        break;
                }
            }
        }
Exemple #29
0
        TableRows _TableRows; // The header rows for the table or group

        #endregion Fields

        #region Constructors

        // each page that the table (or group) is displayed
        internal Header(ReportDefn r, ReportLink p, XmlNode xNode)
            : base(r, p)
        {
            _TableRows=null;
            _RepeatOnNewPage=false;

            // Loop thru all the child nodes
            foreach(XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                    continue;
                switch (xNodeLoop.Name)
                {
                    case "TableRows":
                        _TableRows = new TableRows(r, this, xNodeLoop);
                        break;
                    case "RepeatOnNewPage":
                        _RepeatOnNewPage = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                        break;
                    default:
                        break;
                }
            }
            if (_TableRows == null)
                OwnerReport.rl.LogError(8, "Header requires the TableRows element.");
        }
        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();
        }
Exemple #31
0
        bool _FilterOperatorSingleRow;                  // false for Top/Bottom N and Percent; otherwise true
        internal Filter(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
        {
            _FilterExpression = null;
            _FilterOperator   = FilterOperatorEnum.Unknown;
            _FilterValues     = null;

            // Loop thru all the child nodes
            foreach (XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (xNodeLoop.Name)
                {
                case "FilterExpression":
                    _FilterExpression = new Expression(r, this, xNodeLoop, ExpressionType.Variant);
                    break;

                case "Operator":
                    _FilterOperator = Engine.FilterOperator.GetStyle(xNodeLoop.InnerText);
                    if (_FilterOperator == FilterOperatorEnum.Unknown)
                    {
                        OwnerReport.rl.LogError(8, "Unknown Filter operator '" + xNodeLoop.InnerText + "'.");
                    }
                    break;

                case "FilterValues":
                    _FilterValues = new FilterValues(r, this, xNodeLoop);
                    break;

                default:
                    // don't know this element - log it
                    OwnerReport.rl.LogError(4, "Unknown Filter element '" + xNodeLoop.Name + "' ignored.");
                    break;
                }
            }
            if (_FilterExpression == null)
            {
                OwnerReport.rl.LogError(8, "Filter requires the FilterExpression element.");
            }
            if (_FilterValues == null)
            {
                OwnerReport.rl.LogError(8, "Filter requires the FilterValues element.");
                return;                         // some of the filter operator checks require values
            }
            _FilterOperatorSingleRow = true;
            switch (_FilterOperator)
            {
            case FilterOperatorEnum.Like:
            case FilterOperatorEnum.Equal:
            case FilterOperatorEnum.NotEqual:
            case FilterOperatorEnum.GreaterThan:
            case FilterOperatorEnum.GreaterThanOrEqual:
            case FilterOperatorEnum.LessThan:
            case FilterOperatorEnum.LessThanOrEqual:
                if (_FilterValues.Items.Count != 1)
                {
                    OwnerReport.rl.LogError(8, "Filter Operator requires exactly 1 FilterValue.");
                }
                break;

            case FilterOperatorEnum.TopN:
            case FilterOperatorEnum.BottomN:
            case FilterOperatorEnum.TopPercent:
            case FilterOperatorEnum.BottomPercent:
                _FilterOperatorSingleRow = false;
                if (_FilterValues.Items.Count != 1)
                {
                    OwnerReport.rl.LogError(8, "Filter Operator requires exactly 1 FilterValue.");
                }
                break;

            case FilterOperatorEnum.In:
                break;

            case FilterOperatorEnum.Between:
                if (_FilterValues.Items.Count != 2)
                {
                    OwnerReport.rl.LogError(8, "Filter Operator Between requires exactly 2 FilterValues.");
                }
                break;

            default:
                OwnerReport.rl.LogError(8, "Valid Filter operator must be specified.");
                break;
            }
        }
Exemple #32
0
        List <Textbox> _HideDuplicates;         // holds any textboxes that use this as a hideduplicate scope

        internal DataSetDefn(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
        {
            _Name                = null;
            _Fields              = null;
            _Query               = null;
            _CaseSensitivity     = TrueFalseAutoEnum.True;
            _Collation           = null;
            _AccentSensitivity   = TrueFalseAutoEnum.False;
            _KanatypeSensitivity = TrueFalseAutoEnum.False;
            _WidthSensitivity    = TrueFalseAutoEnum.False;
            _Filters             = null;
            _HideDuplicates      = null;
            // Run thru the attributes
            foreach (XmlAttribute xAttr in xNode.Attributes)
            {
                switch (xAttr.Name)
                {
                case "Name":
                    _Name = new Name(xAttr.Value);
                    break;
                }
            }

            // Loop thru all the child nodes
            foreach (XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (xNodeLoop.Name)
                {
                case "Fields":
                    _Fields = new Fields(r, this, xNodeLoop);
                    break;

                case "Query":
                    _Query = new Query(r, this, xNodeLoop);
                    break;

                case "Rows":                            // Extension !!!!!!!!!!!!!!!!!!!!!!!
                case "fyi:Rows":
                    _XmlRowData = "<?xml version='1.0' encoding='UTF-8'?><Rows>" + xNodeLoop.InnerXml + "</Rows>";
                    foreach (XmlAttribute xA in xNodeLoop.Attributes)
                    {
                        if (xA.Name == "File")
                        {
                            _XmlRowFile = xA.Value;
                        }
                    }
                    break;

                case "CaseSensitivity":
                    _CaseSensitivity = TrueFalseAuto.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "Collation":
                    _Collation = xNodeLoop.InnerText;
                    break;

                case "AccentSensitivity":
                    _AccentSensitivity = TrueFalseAuto.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "KanatypeSensitivity":
                    _KanatypeSensitivity = TrueFalseAuto.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "WidthSensitivity":
                    _WidthSensitivity = TrueFalseAuto.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "Filters":
                    _Filters = new Filters(r, this, xNodeLoop);
                    break;

                default:
                    OwnerReport.rl.LogError(4, "Unknown DataSet element '" + xNodeLoop.Name + "' ignored.");
                    break;
                }
            }
            if (this.Name != null)
            {
                OwnerReport.LUAggrScope.Add(this.Name.Nm, this);                                // add to referenceable TextBoxes
            }
            else
            {
                OwnerReport.rl.LogError(4, "Name attribute must be specified in a DataSet.");
            }

            if (_Query == null)
            {
                OwnerReport.rl.LogError(8, "Query element must be specified in a DataSet.");
            }
        }
Exemple #33
0
        internal TypeCode DoParse(Report rpt)
        {
            // optimization: avoid expression overhead if this isn't really an expression
            if (_Source == null)
            {
                _Expr = new Constant("");
                return(_Expr.GetTypeCode());
            }
            else if (_Source == string.Empty ||         // empty expression
                     _Source[0] != '=')                 // if 1st char not '='
            {
                _Expr = new Constant(_Source);          //   this is a constant value
                return(_Expr.GetTypeCode());
            }

            Parser p = new Parser(new System.Collections.Generic.List <ICacheData>());

            // find the fields that are part of the DataRegion (if there is one)
            IDictionary fields = null;
            ReportLink  dr     = _rl.Parent;
            Grouping    grp    = null;                  // remember if in a table group or detail group or list group
            Matrix      m      = null;

            while (dr != null)
            {
                if (dr is Grouping)
                {
                    p.NoAggregateFunctions = true;
                }
                else if (dr is TableGroup)
                {
                    grp = ((TableGroup)dr).Grouping;
                }
                else if (dr is Matrix)
                {
                    m = (Matrix)dr;                                     // if matrix we need to pass special
                    break;
                }
                else if (dr is Details)
                {
                    grp = ((Details)dr).Grouping;
                }
                else if (dr is List)
                {
                    grp = ((List)dr).Grouping;
                    break;
                }
                else if (dr is DataRegion || dr is DataSetDefn)
                {
                    break;
                }
                dr = dr.Parent;
            }
            if (dr != null)
            {
                if (dr is DataSetDefn)
                {
                    DataSetDefn d = (DataSetDefn)dr;
                    if (d.Fields != null)
                    {
                        fields = d.Fields.Items;
                    }
                }
                else                    // must be a DataRegion
                {
                    DataRegion d = (DataRegion)dr;
                    if (d.DataSetDefn != null &&
                        d.DataSetDefn.Fields != null)
                    {
                        fields = d.DataSetDefn.Fields.Items;
                    }
                }
            }

            NameLookup lu = new NameLookup(fields, rpt.ReportDefinition.LUReportParameters,
                                           rpt.ReportDefinition.LUReportItems, rpt.ReportDefinition.LUGlobals,
                                           rpt.ReportDefinition.LUUser, rpt.ReportDefinition.LUAggrScope,
                                           grp, m, rpt.ReportDefinition.CodeModules, rpt.ReportDefinition.Classes, rpt.ReportDefinition.DataSetsDefn,
                                           rpt.ReportDefinition.CodeType);

            try
            {
                _Expr = p.Parse(lu, _Source);
            }
            catch (Exception e)
            {
                _Expr = new ConstantError(e.Message);
                // Invalid expression
                rpt.rl.LogError(8, ErrorText(e.Message));
            }

            // Optimize removing any expression that always result in a constant
            try
            {
                _Expr = _Expr.ConstantOptimization();
            }
            catch (Exception ex)
            {
                rpt.rl.LogError(4, "Expression:" + _Source + "\r\nConstant Optimization exception:\r\n" + ex.Message + "\r\nStack trace:\r\n" + ex.StackTrace);
            }

            return(_Expr.GetTypeCode());
        }
Exemple #34
0
        internal Chart(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p, xNode)
        {
            _Type                   = ChartTypeEnum.Column;
            _Subtype                = new Expression(r, p, "Plain", ExpressionType.Enum); //AJM GJL 14082008 Allowing Expression
            _SeriesGroupings        = null;
            _CategoryGroupings      = null;
            _ChartData              = null;
            _Legend                 = null;
            _CategoryAxis           = null;
            _ValueAxis              = null;
            _Title                  = null;
            _PointWidth             = 0;
            _Palette                = new Expression(r, p, "Default", ExpressionType.Enum); //AJM GJL 14082008 Allowing Expression
            _ThreeDProperties       = null;
            _PlotArea               = null;
            _ChartElementOutput     = ChartElementOutputEnum.Output;
            _isHYNEsWonderfulVector = new Expression(r, p, "False", ExpressionType.Boolean);
            _showTooltips           = new Expression(r, p, "False", ExpressionType.Boolean);
            _showTooltipsX          = new Expression(r, p, "False", ExpressionType.Boolean);
            _ToolTipXFormat         = new Expression(r, p, "", ExpressionType.String);
            _ToolTipYFormat         = new Expression(r, p, "", ExpressionType.String);

            // Loop thru all the child nodes
            foreach (XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (xNodeLoop.Name)
                {
                case "Type":
                    _Type = ChartType.GetStyle(xNodeLoop.InnerText);
                    if (_Type == ChartTypeEnum.Stock ||
                        _Type == ChartTypeEnum.Unknown)
                    {
                        OwnerReport.rl.LogError(8, "Chart type '" + xNodeLoop.InnerText + "' is not currently supported.");
                    }
                    break;

                case "Subtype":
                    _Subtype = new Expression(r, p, xNodeLoop, ExpressionType.Enum);     //AJM GJL 14082008
                    break;

                case "SeriesGroupings":
                    _SeriesGroupings = new SeriesGroupings(r, this, xNodeLoop);
                    break;

                case "CategoryGroupings":
                    _CategoryGroupings = new CategoryGroupings(r, this, xNodeLoop);
                    break;

                case "ChartData":
                    _ChartData = new ChartData(r, this, xNodeLoop);
                    break;

                case "Legend":
                    _Legend = new Legend(r, this, xNodeLoop);
                    break;

                case "CategoryAxis":
                    _CategoryAxis = new CategoryAxis(r, this, xNodeLoop);
                    break;

                case "ValueAxis":
                    _ValueAxis = new ValueAxis(r, this, xNodeLoop);
                    break;

                case "Title":
                    _Title = new Title(r, this, xNodeLoop);
                    break;

                case "PointWidth":
                    _PointWidth = XmlUtil.Integer(xNodeLoop.InnerText);
                    break;

                case "Palette":
                    _Palette = new Expression(r, p, xNodeLoop, ExpressionType.Enum);     //AJM GJL 14082008
                    break;

                case "ThreeDProperties":
                    _ThreeDProperties = new ThreeDProperties(r, this, xNodeLoop);
                    break;

                case "PlotArea":
                    _PlotArea = new PlotArea(r, this, xNodeLoop);
                    break;

                case "ChartElementOutput":
                    _ChartElementOutput = Engine.ChartElementOutput.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "HyneWonderfulVector":     //AJM GJL 14082008
                case "RenderAsVector":
                case "fyi:RenderAsVector":
                    _isHYNEsWonderfulVector = new Expression(r, p, xNodeLoop, ExpressionType.Boolean);
                    break;

                case "fyi:tooltip":
                case "fyi:Tooltip":
                    _showTooltips = new Expression(r, p, xNodeLoop, ExpressionType.Boolean);
                    break;

                case "fyi:TooltipX":
                    _showTooltipsX = new Expression(r, p, xNodeLoop, ExpressionType.Boolean);
                    break;

                case "fyi:TooltipYFormat":
                    _ToolTipYFormat = new Expression(r, p, xNodeLoop, ExpressionType.Boolean);
                    break;

                case "fyi:TooltipXFormat":
                    _ToolTipXFormat = new Expression(r, p, xNodeLoop, ExpressionType.Boolean);
                    break;

                default:
                    if (DataRegionElement(xNodeLoop))                                   // try at DataRegion level
                    {
                        break;
                    }
                    // don't know this element - log it
                    OwnerReport.rl.LogError(4, "Unknown Chart element '" + xNodeLoop.Name + "' ignored.");
                    break;
                }
            }
            DataRegionFinish();                                 // Tidy up the DataRegion

            if (_SeriesGroupings == null && _CategoryGroupings == null)
            {
                OwnerReport.rl.LogError(8, "Chart requires either the SeriesGroupings element or CategoryGroupings element or both.");
            }

            if (OwnerReport.rl.MaxSeverity > 4)     // if we already have severe error don't check for these additional issues
            {
                return;
            }

            // Do some specific checking based on the type of the Chart specified
            switch (_Type)
            {
            case ChartTypeEnum.Bubble:
                if (_ChartData == null ||
                    _ChartData.Items[0].Datapoints.Items[0].DataValues.Items.Count != 3)
                {
                    OwnerReport.rl.LogError(8, "Bubble charts require three DataPoints defined.");
                }
                break;

            case ChartTypeEnum.Scatter:
                if (_ChartData == null ||
                    _ChartData.Items[0].Datapoints.Items[0].DataValues.Items.Count != 2)
                {
                    OwnerReport.rl.LogError(8, "Scatter charts require two DataPoints defined.");
                }
                break;

            default:
                break;
            }
        }
        bool _InMatrix;                           // true if grouping is in a matrix

        internal Grouping(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
        {
            _Name               = null;
            _Label              = null;
            _GroupExpressions   = null;
            _PageBreakAtStart   = false;
            _PageBreakAtEnd     = false;
            _Custom             = null;
            _Filters            = null;
            _ParentGroup        = null;
            _DataElementName    = null;
            _DataCollectionName = null;
            _DataElementOutput  = DataElementOutputEnum.Output;
            _HideDuplicates     = null;
            // Run thru the attributes
            foreach (XmlAttribute xAttr in xNode.Attributes)
            {
                switch (xAttr.Name)
                {
                case "Name":
                    _Name = new Name(xAttr.Value);
                    break;
                }
            }
            // Loop thru all the child nodes
            foreach (XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (xNodeLoop.Name)
                {
                case "Label":
                    _Label = new Expression(r, this, xNodeLoop, ExpressionType.String);
                    break;

                case "GroupExpressions":
                    _GroupExpressions = new GroupExpressions(r, this, xNodeLoop);
                    break;

                case "PageBreakAtStart":
                    _PageBreakAtStart = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "PageBreakAtEnd":
                    _PageBreakAtEnd = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "Custom":
                    _Custom = new Custom(r, this, xNodeLoop);
                    break;

                case "Filters":
                    _Filters = new Filters(r, this, xNodeLoop);
                    break;

                case "Parent":
                    _ParentGroup = new Expression(r, this, xNodeLoop, ExpressionType.Variant);
                    break;

                case "DataElementName":
                    _DataElementName = xNodeLoop.InnerText;
                    break;

                case "DataCollectionName":
                    _DataCollectionName = xNodeLoop.InnerText;
                    break;

                case "DataElementOutput":
                    _DataElementOutput = Engine.DataElementOutput.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                default:
                    // don't know this element - log it
                    OwnerReport.rl.LogError(4, "Unknown Grouping element '" + xNodeLoop.Name + "' ignored.");
                    break;
                }
            }
            if (this.Name != null)
            {
                try
                {
                    OwnerReport.LUAggrScope.Add(this.Name.Nm, this); // add to referenceable Grouping's
                }
                catch                                                // wish duplicate had its own exception
                {
                    OwnerReport.rl.LogError(8, "Duplicate Grouping name '" + this.Name.Nm + "'.");
                }
            }
            if (_GroupExpressions == null)
            {
                OwnerReport.rl.LogError(8, "Group Expressions are required within group '" + (this.Name == null? "unnamed": this.Name.Nm) + "'.");
            }
        }
Exemple #36
0
        internal Table(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p, xNode)
        {
            _TableColumns             = null;
            _Header                   = null;
            _TableGroups              = null;
            _Details                  = null;
            _Footer                   = null;
            _FillPage                 = true;
            _DetailDataElementName    = "Details";
            _DetailDataCollectionName = "Details_Collection";
            _DetailDataElementOutput  = DataElementOutputEnum.Output;
            _IsGrid                   = xNode.Name != "Table"; // a grid is a restricted table to no data behind it

            // Loop thru all the child nodes
            foreach (XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (xNodeLoop.Name)
                {
                case "TableColumns":
                    _TableColumns = new TableColumns(r, this, xNodeLoop);
                    break;

                case "Header":
                    _Header = new Header(r, this, xNodeLoop);
                    break;

                case "TableGroups":
                    _TableGroups = new TableGroups(r, this, xNodeLoop);
                    break;

                case "Details":
                    _Details = new Details(r, this, xNodeLoop);
                    break;

                case "Footer":
                    _Footer = new Footer(r, this, xNodeLoop);
                    break;

                case "FillPage":
                    _FillPage = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "DetailDataElementName":
                    _DetailDataElementName = xNodeLoop.InnerText;
                    break;

                case "DetailDataCollectionName":
                    _DetailDataCollectionName = xNodeLoop.InnerText;
                    break;

                case "DetailDataElementOutput":
                    _DetailDataElementOutput = Engine.DataElementOutput.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                default:
                    if (DataRegionElement(xNodeLoop))                                   // try at DataRegion level
                    {
                        break;
                    }
                    // don't know this element - log it
                    OwnerReport.rl.LogError(4, "Unknown " + xNode.Name + " element '" + xNodeLoop.Name + "' ignored.");
                    break;
                }
            }
            DataRegionFinish();                                 // Tidy up the DataRegion
            if (_TableColumns == null)
            {
                OwnerReport.rl.LogError(8, "TableColumns element must be specified for a " + xNode.Name + ".");
                return;
            }

            // Verify Grid restrictions
            if (_IsGrid)
            {
                if (_TableGroups != null)
                {
                    OwnerReport.rl.LogError(8, "TableGroups not allowed in Grid element '" + xNode.Name + "'.");
                }
            }

            if (OwnerReport.rl.MaxSeverity < 8)
            {
                VerifyCC();                                     // Verify column count
            }
        }
Exemple #37
0
        Assembly _Assembly;                     // the compiled assembly

        internal Code(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
        {
            _Source   = xNode.InnerText;
            _Assembly = GetAssembly();
        }
Exemple #38
0
        string _ImageData;              // Base-64 encoded image data.

        internal EmbeddedImage(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
        {
            _Name      = null;
            _MIMEType  = null;
            _ImageData = null;
            // Run thru the attributes
            foreach (XmlAttribute xAttr in xNode.Attributes)
            {
                switch (xAttr.Name)
                {
                case "Name":
                    _Name = new Name(xAttr.Value);
                    break;
                }
            }
            // Loop thru all the child nodes
            foreach (XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (xNodeLoop.Name)
                {
                case "MIMEType":
                    _MIMEType = xNodeLoop.InnerText;
                    break;

                case "ImageData":
                    _ImageData = xNodeLoop.InnerText;
                    break;

                default:
                    this.OwnerReport.rl.LogError(4, "Unknown Report element '" + xNodeLoop.Name + "' ignored.");
                    break;
                }
            }

            if (this.Name == null)
            {
                OwnerReport.rl.LogError(8, "EmbeddedImage Name is required but not specified.");
            }
            else
            {
                try
                {
                    OwnerReport.LUEmbeddedImages.Add(this.Name.Nm, this); // add to referenceable embedded images
                }
                catch                                                     // Duplicate name
                {
                    OwnerReport.rl.LogError(4, "Duplicate EmbeddedImage  name '" + this.Name.Nm + "' ignored.");
                }
            }
            if (_MIMEType == null)
            {
                OwnerReport.rl.LogError(8, "EmbeddedImage MIMEType is required but not specified for " + (this.Name == null? "'name not specified'": this.Name.Nm));
            }

            if (_ImageData == null)
            {
                OwnerReport.rl.LogError(8, "EmbeddedImage ImageData is required but not specified for " + (this.Name == null? "'name not specified'": this.Name.Nm));
            }
        }
        List <ReportItem> _Items;                                       // list of report items

        internal ReportItems(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
        {
            ReportItem ri;

            _Items = new List <ReportItem>();

            // Loop thru all the child nodes
            foreach (XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (xNodeLoop.Name)
                {
                case "Rectangle":
                    ri = new Rectangle(r, this, xNodeLoop);
                    break;

                case "Line":
                    ri = new Line(r, this, xNodeLoop);
                    break;

                case "Textbox":
                    ri = new Textbox(r, this, xNodeLoop);
                    break;

                case "Image":
                    ri = new Image(r, this, xNodeLoop);
                    break;

                case "Subreport":
                    ri = new Subreport(r, this, xNodeLoop);
                    break;

                // DataRegions: list, table, matrix, chart
                case "List":
                    ri = new List(r, this, xNodeLoop);
                    break;

                case "Table":
                case "Grid":
                case "fyi:Grid":
                    ri = new Table(r, this, xNodeLoop);
                    break;

                case "Matrix":
                    ri = new Matrix(r, this, xNodeLoop);
                    break;

                case "Chart":
                    ri = new Chart(r, this, xNodeLoop);
                    break;

                case "ChartExpression":                                 // For internal use only
                    ri = new ChartExpression(r, this, xNodeLoop);
                    break;

                case "CustomReportItem":
                    ri = new CustomReportItem(r, this, xNodeLoop);
                    break;

                default:
                    ri = null;                                          // don't know what this is
                    // don't know this element - log it
                    OwnerReport.rl.LogError(4, "Unknown ReportItems element '" + xNodeLoop.Name + "' ignored.");
                    break;
                }
                if (ri != null)
                {
                    _Items.Add(ri);
                }
            }
            if (_Items.Count == 0)
            {
                OwnerReport.rl.LogError(8, "At least one item must be in the ReportItems.");
            }
            else
            {
                _Items.TrimExcess();
            }
        }
Exemple #40
0
 internal void Add(ReportLink rl, string name, object o)
 {
     _RunCache.Add(GetKey(rl, name), o);
 }
Exemple #41
0
 internal ReportLink(ReportDefn r, ReportLink p)
 {
     OwnerReport  = r;
     Parent       = p;
     ObjectNumber = r.GetObjectNumber();
 }
        bool _Clustered;                                    // Determines if data series are clustered
        // (displayed along distinct rows). Only
        // applies to bar and column chart types.  Defaults to false.

        internal ThreeDProperties(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
        {
            _Enabled        = false;
            _ProjectionMode = ThreeDPropertiesProjectionModeEnum.Perspective;
            _Rotation       = 0;
            _Inclination    = 0;
            _Perspective    = 0;
            _HeightRatio    = 0;
            _DepthRatio     = 0;
            _Shading        = ThreeDPropertiesShadingEnum.None;
            _GapDepth       = 0;
            _WallThickness  = 0;
            _DrawingStyle   = ThreeDPropertiesDrawingStyleEnum.Cube;
            _Clustered      = false;

            // Loop thru all the child nodes
            foreach (XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (xNodeLoop.Name)
                {
                case "Enabled":
                    _Enabled = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "ProjectionMode":
                    _ProjectionMode = ThreeDPropertiesProjectionMode.GetStyle(xNodeLoop.InnerText);
                    break;

                case "Rotation":
                    _Rotation = XmlUtil.Integer(xNodeLoop.InnerText);
                    break;

                case "Inclination":
                    _Inclination = XmlUtil.Integer(xNodeLoop.InnerText);
                    break;

                case "Perspective":
                    _Perspective = XmlUtil.Integer(xNodeLoop.InnerText);
                    break;

                case "HeightRatio":
                    _HeightRatio = XmlUtil.Integer(xNodeLoop.InnerText);
                    break;

                case "DepthRatio":
                    _DepthRatio = XmlUtil.Integer(xNodeLoop.InnerText);
                    break;

                case "Shading":
                    _Shading = ThreeDPropertiesShading.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "GapDepth":
                    _GapDepth = XmlUtil.Integer(xNodeLoop.InnerText);
                    break;

                case "WallThickness":
                    _WallThickness = XmlUtil.Integer(xNodeLoop.InnerText);
                    break;

                case "DrawingStyle":
                    _DrawingStyle = ThreeDPropertiesDrawingStyle.GetStyle(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                case "Clustered":
                    _Clustered = XmlUtil.Boolean(xNodeLoop.InnerText, OwnerReport.rl);
                    break;

                default:
                    break;
                }
            }
        }
Exemple #43
0
 internal object Get(ReportLink rl, string name)
 {
     return(_RunCache[GetKey(rl, name)]);
 }
        bool _InTableFooter;                    // true if tablecell is part of footer; simplifies HTML processing

        internal TableCell(ReportDefn r, ReportLink p, XmlNode xNode, int colIndex) : base(r, p)
        {
            _ColIndex    = colIndex;
            _ReportItems = null;
            _ColSpan     = 1;

            // Loop thru all the child nodes
            foreach (XmlNode xNodeLoop in xNode.ChildNodes)
            {
                if (xNodeLoop.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                switch (xNodeLoop.Name)
                {
                case "ReportItems":
                    _ReportItems = new ReportItems(r, this, xNodeLoop);
                    break;

                case "ColSpan":
                    _ColSpan = XmlUtil.Integer(xNodeLoop.InnerText);
                    break;

                default:
                    // don't know this element - log it
                    OwnerReport.rl.LogError(4, "Unknown TableCell element '" + xNodeLoop.Name + "' ignored.");
                    break;
                }
            }
            // Must have exactly one ReportItems
            if (_ReportItems == null)
            {
                OwnerReport.rl.LogError(8, "ReportItems element is required with a TableCell but not specified.");
            }
            else if (_ReportItems.Items.Count != 1)
            {
                OwnerReport.rl.LogError(8, "Only one element in ReportItems element is allowed within a TableCell.");
            }

            // Obtain the tablecell's owner table;
            //		determine if tablecell is part of table header
            _InTableHeader = false;
            ReportLink rl;

            for (rl = this.Parent; rl != null; rl = rl.Parent)
            {
                if (rl is Table)
                {
                    _OwnerTable = (Table)rl;
                    break;
                }

                if (rl is Header && rl.Parent is Table)                 // Header and parent is Table (not TableGroup)
                {
                    _InTableHeader = true;
                }

                if (rl is Footer && rl.Parent is Table)                 // Header and parent is Table (not TableGroup)
                {
                    _InTableFooter = true;
                }
            }
            return;
        }
Exemple #45
0
        public void TableRowStart(TableRow tr, Row row)
        {
            Table  t    = null;
            Header head = null;

            for (ReportLink rl = tr.Parent.Parent; rl != null; rl = rl.Parent)
            {
                if (rl is Table)
                {
                    t = rl as Table;
                    break;
                }
                else if (rl is Header)
                {
                    head = rl as Header;
                }
            }
            if (t == null)
            {
                return;
            }

            tw.Write(@"\trowd \trql\trgaph108\trrh0\trleft236");
            if (head != null && head.RepeatOnNewPage)       // repeat table header on multiple pages
            {
                tw.Write(@"\trhdr");
            }

            int pos = 0;

            int ci = 0;

            int columnIndex = 0;

            for (int i = 0; i < tr.TableCells.Items.Count; i++)
            {
                var cell = tr.TableCells.Items[i];

                for (int offset = 0; offset < cell.ColSpan; offset++)
                {
                    var column = t.TableColumns[columnIndex];
                    pos += column.Width.Twips;
                }

                string border = @"\clbrdrt\brdrth\clbrdrl\brdrs\clbrdrb\brdrs\clbrdrr\brdrs";

                var style = cell.ReportItems[0].Style;

                if (style != null)
                {
                    StyleInfo si = style.GetStyleInfo(r, row);
                    border = string.Format(@"\clbrdrt\{0}\clbrdrl\{1}\clbrdrb\{2}\clbrdrr\{3}",
                                           GetBorderStyle(si.BStyleTop),
                                           GetBorderStyle(si.BStyleLeft),
                                           GetBorderStyle(si.BStyleBottom),
                                           GetBorderStyle(si.BStyleRight));
                }

                tw.Write(@"{1}\cellx{0}", pos, border);
            }

            tw.Write(@"\pard \intbl");
        }
Exemple #46
0
        override internal void FinalPass()
        {
            // optimization: avoid expression overhead if this isn't really an expression
            if (_Source == null)
            {
                _Expr = new Constant("");
                return;
            }
            else if (_Source == "" ||                   // empty expression
                     _Source[0] != '=')                 // if 1st char not '='
            {
                _Expr = new Constant(_Source);          //   this is a constant value
                return;
            }

            Parser p = new Parser(OwnerReport.DataCache);

            // find the fields that are part of the DataRegion (if there is one)
            IDictionary fields = null;
            ReportLink  dr     = Parent;
            Grouping    grp    = null;                  // remember if in a table group or detail group or list group
            Matrix      m      = null;
            ReportLink  phpf   = null;

            while (dr != null)
            {
                if (dr is Grouping)
                {
                    p.NoAggregateFunctions = true;
                }
                else if (dr is TableGroup)
                {
                    grp = ((TableGroup)dr).Grouping;
                }
                else if (dr is Matrix)
                {
                    m = (Matrix)dr;                                     // if matrix we need to pass special
                    break;
                }
                else if (dr is Details)
                {
                    grp = ((Details)dr).Grouping;
                }
                else if (dr is List)
                {
                    grp = ((List)dr).Grouping;
                    break;
                }
                else if (dr is PageHeader || dr is PageFooter)
                {
                    phpf = dr;
                }
                else if (dr is DataRegion || dr is DataSetDefn)
                {
                    break;
                }
                dr = dr.Parent;
            }
            if (dr != null)
            {
                if (dr is DataSetDefn)
                {
                    DataSetDefn d = (DataSetDefn)dr;
                    if (d.Fields != null)
                    {
                        fields = d.Fields.Items;
                    }
                }
                else                    // must be a DataRegion
                {
                    DataRegion d = (DataRegion)dr;
                    if (d.DataSetDefn != null &&
                        d.DataSetDefn.Fields != null)
                    {
                        fields = d.DataSetDefn.Fields.Items;
                    }
                }
            }

            NameLookup lu = new NameLookup(fields, OwnerReport.LUReportParameters,
                                           OwnerReport.LUReportItems, OwnerReport.LUGlobals,
                                           OwnerReport.LUUser, OwnerReport.LUAggrScope,
                                           grp, m, OwnerReport.CodeModules, OwnerReport.Classes, OwnerReport.DataSetsDefn,
                                           OwnerReport.CodeType);

            if (phpf != null)
            {
                // Non-null when expression is in PageHeader or PageFooter;
                //   Expression name needed for dynamic lookup of ReportItems on a page.
                lu.PageFooterHeader = phpf;
                lu.ExpressionName   = _UniqueName = "xn_" + Interlocked.Increment(ref Parser.Counter).ToString();
            }

            try
            {
                _Expr = p.Parse(lu, _Source);
            }
            catch (Exception e)
            {
                _Expr = new ConstantError(e.Message);
                // Invalid expression
                OwnerReport.rl.LogError(8, ErrorText(e.Message));
            }

            // Optimize removing any expression that always result in a constant
            try
            {
                _Expr = _Expr.ConstantOptimization();
            }
            catch (Exception ex)
            {
                OwnerReport.rl.LogError(4, "Expression:" + _Source + "\r\nConstant Optimization exception:\r\n" + ex.Message + "\r\nStack trace:\r\n" + ex.StackTrace);
            }
            _Type = _Expr.GetTypeCode();

            return;
        }
Exemple #47
0
 internal void Remove(ReportLink rl, string name)
 {
     _RunCache.Remove(GetKey(rl, name));
 }
Exemple #48
0
        Expression _Expression;                         //

        internal FilterValue(ReportDefn r, ReportLink p, XmlNode xNode) : base(r, p)
        {
            _Expression = new Expression(r, this, xNode, ExpressionType.Variant);
        }
Exemple #49
0
 string GetKey(ReportLink rl, string name)
 {
     return(GetKey(rl.ObjectNumber, name));
 }
Exemple #50
0
        string _UniqueName;                     // unique name of expression; not always created

        internal Expression(ReportDefn r, ReportLink p, XmlNode xNode, ExpressionType et) : this(r, p, xNode.InnerText, et)
        {
        }