Exemple #1
0
        /// <summary>
        /// Add a new results page with a view of the specified type
        /// </summary>
        /// <param name="query"></param>
        /// <param name="viewType"></param>
        /// <returns></returns>

        public static void AddNewPageAndView(
            Query query,
            ResultsViewType viewType,
            string viewSubtype,
            out ResultsPage page,
            out ResultsViewProps view)
        {
            page = AddNewPage(query);
            view = ResultsViewProps.NewResultsView(query, page, viewType, viewSubtype);             // create the view & add to page
            return;
        }
Exemple #2
0
        /**************************************************************************/
        /******************************* Methods **********************************/
        /**************************************************************************/

        /// <summary>
        /// Basic constructor
        /// </summary>
        public SpotfireViewProps(ResultsViewProps rvp)
        {
            ResultsViewProps = rvp;             // link to parent ResultsViewProps

            if (rvp != null)
            {
                rvp.SpotfireViewProps = this;                       // link rvp to us
            }
            DataTableMaps = new DataTableMapsMsx(this);             // allocate maps and point back up to us
            return;
        }
Exemple #3
0
        /// <summary>
        /// Deserialize into an existing view
        /// </summary>
        /// <param name="serializedPropString"></param>
        /// <param name="q"></param>
        /// <param name="view"></param>

        public static void Deserialize(
            string serializedPropString,
            Query q,
            ResultsViewProps view)
        {
            XmlMemoryStreamTextReader mstr = new XmlMemoryStreamTextReader(serializedPropString);
            XmlTextReader             tr   = mstr.Reader;

            tr.MoveToContent();
            Deserialize(q, tr, view);
            tr.Close();
            return;
        }
Exemple #4
0
        /// <summary>
        /// Deserialize an axis definition
        /// </summary>
        /// <param name="name"></param>
        /// <param name="q"></param>
        /// <param name="tr"></param>
        /// <returns></returns>

        internal static AxisMx DeserializeAxis(
            string axisName,
            Query q,
            XmlTextReader tr)
        {
            Enum iEnum = null;

            AxisMx axis = new AxisMx();

            XmlUtil.GetStringAttribute(tr, "ShortName", ref axis.ShortName);

            XmlUtil.GetStringAttribute(tr, "RangeMin", ref axis.RangeMin);
            XmlUtil.GetStringAttribute(tr, "RangeMax", ref axis.RangeMax);

            XmlUtil.GetBoolAttribute(tr, "IncludeOrigin", ref axis.IncludeOrigin);
            XmlUtil.GetBoolAttribute(tr, "SideMarginsEnabled", ref axis.SideMarginsEnabled);

            XmlUtil.GetBoolAttribute(tr, "ShowLabels", ref axis.ShowLabels);
            XmlUtil.GetIntAttribute(tr, "LabelAngle", ref axis.LabelAngle);
            XmlUtil.GetBoolAttribute(tr, "LabelsStaggered", ref axis.LabelsStaggered);
            if (XmlUtil.GetEnumAttribute(tr, "LabelResolveOverlappingMode", typeof(AxisLabelResolveOverlappingMode), ref iEnum))
            {
                axis.LabelResolveOverlappingMode = (AxisLabelResolveOverlappingMode)iEnum;
            }

            XmlUtil.GetBoolAttribute(tr, "ShowZoomSlider", ref axis.ShowZoomSlider);
            XmlUtil.GetBoolAttribute(tr, "ShowGridLines", ref axis.ShowGridLines);
            XmlUtil.GetBoolAttribute(tr, "ShowGridStrips", ref axis.ShowGridStrips);
            XmlUtil.GetBoolAttribute(tr, "LogScale", ref axis.LogScale);
            XmlUtil.GetBoolAttribute(tr, "ReverseScale", ref axis.ReverseScale);

            tr.Read(); tr.MoveToContent();

            if (Lex.Eq(tr.Name, axisName + "Column"))
            {
                axis.QueryColumn = ResultsViewProps.DeserializeQueryColumnRef(q, tr);
                tr.Read(); tr.MoveToContent();
            }

            if (!Lex.Eq(tr.Name, axisName))
            {
                throw new Exception("Expected " + axisName + " end element");
            }

            return(axis);
        }
Exemple #5
0
        /// <summary>
        /// Serialize vertex
        /// </summary>
        /// <param name="name"></param>
        /// <param name="tw"></param>

        public void Serialize(string name, XmlTextWriter tw)
        {
            if (QueryColumn == null)
            {
                return;
            }

            tw.WriteStartElement(name);

            tw.WriteAttributeString("ShowLabels", ShowLabels.ToString());

            ResultsViewProps.SerializeQueryColumn(QueryColumn, name + "Column", tw);
            Color.Serialize("Color", tw);
            Size.Serialize("Size", tw);
            Shape.Serialize("Shape", tw);
            TooltipFields.Serialize("ToolTipFields", tw);

            tw.WriteEndElement();
            return;
        }
Exemple #6
0
        /// <summary>
        /// Serialize edge
        /// </summary>
        /// <param name="name"></param>
        /// <param name="tw"></param>

        public void Serialize(string name, XmlTextWriter tw)
        {
            if (QueryColumn == null)
            {
                return;
            }

            tw.WriteStartElement(name);

            tw.WriteAttributeString("ShowLabels", ShowLabels.ToString());
            tw.WriteAttributeString("SummarizationType", SummarizationType.ToString());
            tw.WriteAttributeString("IncludeEdgeVertex", IncludeEdgeVertex.ToString());

            ResultsViewProps.SerializeQueryColumn(QueryColumn, name + "Column", tw);
            Color.Serialize("Color", tw);
            Width.Serialize("Width", tw);
            TooltipFields.Serialize("ToolTipFields", tw);

            tw.WriteEndElement();
            return;
        }
Exemple #7
0
        /// <summary>
        /// Deserialize SpotfireViewProp
        /// </summary>
        /// <param name="q"></param>
        /// <param name="tr"></param>
        /// <param name="view"></param>
        /// <returns></returns>

        public static SpotfireViewProps DeserializeSpotfireProperties(
            Query q,
            XmlTextReader tr,
            ResultsViewProps view)
        {
            Enum iEnum = null;

            SpotfireViewProps svp = new SpotfireViewProps(view);

            XmlUtil.GetStringAttribute(tr, "WebPlayerUrl", ref svp.WebplayerUrl);
            XmlUtil.GetStringAttribute(tr, "AnalysisPath", ref svp.AnalysisPath);
            XmlUtil.GetStringAttribute(tr, "Description", ref svp.Description);
            XmlUtil.GetStringAttribute(tr, "ParameterString", ref svp.ParameterString);

            while (true)
            {
                if (!XmlUtil.MoreSubElements(tr, "SpotfireViewProps"))
                {
                    break;
                }

                else if (Lex.Eq(tr.Name, "DataTableMaps"))
                {
                    DataTableMapsMsx.Deserialize(view.BaseQuery, tr, svp);
                }

                else if (Lex.Eq(tr.Name, "SpotfireLinkParameter"))
                {
                    DeserializeSpotfireLinkParameter(tr, svp);
                }


                else
                {
                    throw new Exception("Unexpected element: " + tr.Name);
                }
            }

            return(svp);
        }
Exemple #8
0
        /// <summary>
        /// Serialize Network View Properties
        /// </summary>
        /// <param name="tw"></param>

        public void Serialize(XmlTextWriter tw)
        {
            if (!NetworkPropertiesEnabled)
            {
                return;
            }

            tw.WriteStartElement("NetworkProperties");

            //tw.WriteAttributeString("GraphDirectedness", GraphDirectedness.ToString());

            LayoutSettingsMx s = LayoutSettings;             // layout settings

            //tw.WriteAttributeString("LayoutType", s.LayoutType.ToString());
            //tw.WriteAttributeString("LayoutStyle", s.LayoutStyle.ToString());
            //tw.WriteAttributeString("GroupRectanglePenWidth", s.GroupRectanglePenWidth.ToString());
            //tw.WriteAttributeString("IntergroupEdgeStyle", s.IntergroupEdgeStyle.ToString());
            //tw.WriteAttributeString("ImproveLayoutOfGroups", s.ImproveLayoutOfGroups.ToString());
            //tw.WriteAttributeString("MaximumVerticesPerBin", s.MaximumVerticesPerBin.ToString());
            //tw.WriteAttributeString("BinLength", s.BinLength.ToString());
            //tw.WriteAttributeString("FruchtermanReingoldC", s.FruchtermanReingoldC.ToString());
            //tw.WriteAttributeString("FruchtermanReingoldIterations", s.FruchtermanReingoldIterations.ToString());
            //tw.WriteAttributeString("Margin", s.Margin.ToString());

            //tw.WriteAttributeString("VertexGroupMethod", VertexGroupMethod.ToString());
            //tw.WriteAttributeString("GroupingDisabled", GroupingDisabled.ToString());
            //tw.WriteAttributeString("GraphScale", GraphScale.ToString());

            Vertex1.Serialize("Vertex1", tw);
            Vertex2.Serialize("Vertex1", tw);

            Edge.Serialize("Edge", tw);
            ResultsViewProps.SerializeQueryColumn(GroupByQc, "GroupByQc", tw);

            tw.WriteEndElement();             // NetworkProperties
            return;
        }
Exemple #9
0
        /// <summary>
        /// Deserialize
        /// </summary>
        /// <param name="name"></param>
        /// <param name="q"></param>
        /// <param name="tr"></param>
        /// <returns></returns>

        internal static EdgeMx Deserialize(
            string name,
            Query q,
            XmlTextReader tr)
        {
            Enum iEnum = null;

            EdgeMx e = new EdgeMx();

            if (XmlUtil.GetEnumAttribute(tr, "ShowLabels", typeof(ShowLabels), ref iEnum))
            {
                e.ShowLabels = (ShowLabels)iEnum;
            }

            if (XmlUtil.GetEnumAttribute(tr, "SummarizationType", typeof(SummarizationType), ref iEnum))
            {
                e.SummarizationType = (SummarizationType)iEnum;
            }

            XmlUtil.GetBoolAttribute(tr, "IncludeEdgeVertex", ref e.IncludeEdgeVertex);

            while (true)             // loop through elements of network
            {
                tr.Read(); tr.MoveToContent();

                if (Lex.Eq(tr.Name, name + "Column"))
                {
                    e.QueryColumn = ResultsViewProps.DeserializeQueryColumn(q, tr);
                    tr.Read(); tr.MoveToContent();
                }

                else if (Lex.Eq(tr.Name, "Color"))
                {
                    e.Color = ColorDimension.Deserialize("Color", q, tr);
                    tr.Read(); tr.MoveToContent();
                }

                else if (Lex.Eq(tr.Name, "Width"))
                {
                    e.Width = SizeDimension.Deserialize("Width", q, tr);
                    tr.Read(); tr.MoveToContent();
                }

                else if (Lex.Eq(tr.Name, "TooltipFields"))
                {
                    e.TooltipFields = TooltipDimensionDef.Deserialize("TooltipFields", q, tr);
                    //tr.Read(); tr.MoveToContent();
                }

                else if (tr.NodeType == XmlNodeType.EndElement &&                 // end of props
                         Lex.Eq(tr.Name, name))
                {
                    break;
                }

                else
                {
                    throw new Exception("Unexpected element: " + tr.Name);
                }
            }

            return(e);
        }
Exemple #10
0
/// <summary>
/// Deserialize
/// </summary>
/// <param name="vertexName"></param>
/// <param name="q"></param>
/// <param name="tr"></param>
/// <returns></returns>

        internal static VertexMx Deserialize(
            string name,
            Query q,
            XmlTextReader tr)
        {
            Enum iEnum = null;

            VertexMx v = new VertexMx();

            if (XmlUtil.GetEnumAttribute(tr, "ShowLabels", typeof(ShowLabels), ref iEnum))
            {
                v.ShowLabels = (ShowLabels)iEnum;
            }

            while (true)             // loop through elements of network
            {
                tr.Read(); tr.MoveToContent();

                if (Lex.Eq(tr.Name, name + "Column"))
                {
                    v.QueryColumn = ResultsViewProps.DeserializeQueryColumn(q, tr);
                    //tr.Read(); tr.MoveToContent();
                }

                else if (Lex.Eq(tr.Name, "Color"))
                {
                    v.Color = ColorDimension.Deserialize("Color", q, tr);
                    //tr.Read(); tr.MoveToContent();
                }

                else if (Lex.Eq(tr.Name, "Size"))
                {
                    v.Size = SizeDimension.Deserialize("Size", q, tr);
                    //tr.Read(); tr.MoveToContent();
                }

                else if (Lex.Eq(tr.Name, "Shape"))
                {
                    v.Shape = ShapeDimension.Deserialize("Shape", q, tr);
                    //tr.Read(); tr.MoveToContent();
                }

                else if (Lex.Eq(tr.Name, "TooltipFields"))
                {
                    v.TooltipFields = TooltipDimensionDef.Deserialize("TooltipFields", q, tr);
                    //tr.Read(); tr.MoveToContent();
                }

                else if (tr.NodeType == XmlNodeType.EndElement &&                 // end of props
                         Lex.Eq(tr.Name, name))
                {
                    break;
                }

                else
                {
                    throw new Exception("Unexpected element: " + tr.Name);
                }
            }

            return(v);
        }
Exemple #11
0
/// <summary>
/// Deserialize
/// </summary>
/// <param name="q"></param>
/// <param name="tr"></param>
/// <param name="view"></param>
/// <returns></returns>

        public static bool Deserialize(
            Query q,
            XmlTextReader tr,
            ResultsViewProps view)
        {
            Enum   iEnum = null;
            bool   b1    = false;
            string txt   = "";
            int    i1    = -1;
            double d1    = -1;

            if (!Lex.Eq(tr.Name, "NetworkProperties"))
            {
                return(false);
            }

            if (view.NetworkProperties == null)
            {
                view.NetworkProperties = new NetworkProperties();
            }

            NetworkProperties p = view.NetworkProperties;

            //if (XmlUtil.GetEnumAttribute(tr, "GraphDirectedness", typeof(GraphDirectedness), ref iEnum))
            //	p.GraphDirectedness = (GraphDirectedness)iEnum;

            //LayoutSettingsMx s = p.LayoutSettings; // layout settings

            //if (XmlUtil.GetEnumAttribute(tr, "LayoutType", typeof(LayoutType), ref iEnum))
            //	s.LayoutType = (LayoutType)iEnum;

            //if (XmlUtil.GetEnumAttribute(tr, "LayoutStyle", typeof(LayoutStyle), ref iEnum))
            //	s.LayoutStyle = (LayoutStyle)iEnum;
            //XmlUtil.GetDoubleAttribute(tr, "GroupRectanglePenWidth", ref s.GroupRectanglePenWidth);
            //if (XmlUtil.GetEnumAttribute(tr, "IntergroupEdgeStyle", typeof(IntergroupEdgeStyle), ref iEnum))
            //	s.IntergroupEdgeStyle = (IntergroupEdgeStyle)iEnum;
            //XmlUtil.GetBoolAttribute(tr, "ImproveLayoutOfGroups", ref s.ImproveLayoutOfGroups);
            //XmlUtil.GetIntAttribute(tr, "MaximumVerticesPerBin", ref s.MaximumVerticesPerBin);
            //XmlUtil.GetIntAttribute(tr, "BinLength", ref s.BinLength);
            //XmlUtil.GetFloatAttribute(tr, "FruchtermanReingoldC", ref s.FruchtermanReingoldC);
            //XmlUtil.GetIntAttribute(tr, "FruchtermanReingoldIterations", ref s.FruchtermanReingoldIterations);
            //XmlUtil.GetIntAttribute(tr, "Margin", ref s.Margin);

            //if (XmlUtil.GetEnumAttribute(tr, "VertexGroupMethod", typeof(VertexGroupMethodMx), ref iEnum))
            //	p.VertexGroupMethod = (VertexGroupMethodMx)iEnum;
            //XmlUtil.GetBoolAttribute(tr, "GroupingDisabled", ref p.GroupingDisabled);
            //XmlUtil.GetDoubleAttribute(tr, "GraphScale", ref p.GraphScale);

            if (tr.IsEmptyElement)
            {
                return(true);        // return if no elements
            }
            while (true)             // loop through elements of network
            {
                tr.Read(); tr.MoveToContent();

                if (Lex.Eq(tr.Name, "Vertex1"))
                {
                    p.Vertex1 = VertexMx.Deserialize("Vertex1", q, tr);
                }

                else if (Lex.Eq(tr.Name, "Vertex2"))
                {
                    p.Vertex2 = VertexMx.Deserialize("Vertex2", q, tr);
                }

                else if (Lex.Eq(tr.Name, "Edge"))
                {
                    p.Edge = EdgeMx.Deserialize("Edge", q, tr);
                }

                else if (Lex.Eq(tr.Name, "GroupByQc"))
                {
                    p.GroupByQc = ResultsViewProps.DeserializeQueryColumn(q, tr);
                    tr.Read(); tr.MoveToContent();
                }

                else if (tr.NodeType == XmlNodeType.EndElement &&                 // end of props
                         Lex.Eq(tr.Name, "NetworkProperties"))
                {
                    break;
                }

                else
                {
                    throw new Exception("Unexpected element: " + tr.Name);
                }
            }

            return(true);
        }
Exemple #12
0
 public bool ShowScaleLabels(ResultsViewProps view)         // see if we should show scale labels
 {
     return(view.ShowAxesTitles && ShowLabels);
 }
Exemple #13
0
        /// <summary>
        /// Deserialize Chart Properties
        /// </summary>
        /// <param name="q"></param>
        /// <param name="tr"></param>
        /// <param name="view"></param>

        public static bool DeserializeChartProperties(
            Query q,
            XmlTextReader tr,
            ResultsViewProps view)
        {
            AxisMx ax;
            Enum   iEnum = null;
            string txt;

            if (!Lex.Eq(tr.Name, "ChartProperties"))
            {
                return(false);
            }

            if (XmlUtil.GetEnumAttribute(tr, "ShapeRenderingMode", typeof(ShapeRenderingMode), ref iEnum))
            {
                view.ShapeRenderingMode = (ShapeRenderingMode)iEnum;
            }

            //XmlUtil.GetStringAttribute(tr, "BackgroundImageFile", ref view.BackgroundImageFile);
            XmlUtil.GetIntAttribute(tr, "Jitter", ref view.JitterX);
            XmlUtil.GetBoolAttribute(tr, "ChartStretch", ref view.JitterTheSameForXandY);

            XmlUtil.GetBoolAttribute(tr, "ShowLegend", ref view.ShowLegend);

            if (tr.GetAttribute("LegendAlignmentHorizontal") != null)
            {
                view.LegendAlignmentHorizontal =
                    (LegendAlignmentHorizontal)EnumUtil.Parse(typeof(LegendAlignmentHorizontal), tr.GetAttribute("LegendAlignmentHorizontal"));
            }

            if (tr.GetAttribute("LegendAlignmentVertical") != null)
            {
                view.LegendAlignmentVertical =
                    (LegendAlignmentVertical)EnumUtil.Parse(typeof(LegendAlignmentVertical), tr.GetAttribute("LegendAlignmentVertical"));
            }

            XmlUtil.GetIntAttribute(tr, "LegendMaxHorizontalPercentage", ref view.LegendMaxHorizontalPercentage);
            XmlUtil.GetIntAttribute(tr, "LegendMaxVerticalPercentage", ref view.LegendMaxVerticalPercentage);

            if (tr.GetAttribute("LegendItemOrder") != null)
            {
                view.LegendItemOrder =
                    (LegendDirection)EnumUtil.Parse(typeof(LegendDirection), tr.GetAttribute("LegendItemOrder"));
            }

            XmlUtil.GetBoolAttribute(tr, "MainChartAreaMaximized", ref view.MainViewPanelMaximized);
            XmlUtil.GetBoolAttribute(tr, "ShowFilters", ref view.ShowFilters);
            XmlUtil.GetBoolAttribute(tr, "ShowSelectedDataRows", ref view.ShowSelectedDataRows);

            XmlUtil.GetBoolAttribute(tr, "ShowAxesTitles", ref view.ShowAxesTitles);
            XmlUtil.GetBoolAttribute(tr, "ShowAxesScaleLabels", ref view.ShowAxesScaleLabels);
            XmlUtil.GetBoolAttribute(tr, "RotateAxes", ref view.RotateAxes);

            XmlUtil.GetBoolAttribute(tr, "UseExistingCondFormatting", ref view.UseExistingCondFormatting);
            XmlUtil.GetBoolAttribute(tr, "PivotedData", ref view.PivotedData);

            while (true)             // loop through elements of chart
            {
                tr.Read(); tr.MoveToContent();

                if (Lex.Eq(tr.Name, "XAxis"))
                {
                    view.XAxisMx = AxisMx.DeserializeAxis("XAxis", q, tr);
                }

                else if (Lex.Eq(tr.Name, "YAxis"))
                {
                    view.YAxisMx = AxisMx.DeserializeAxis("YAxis", q, tr);
                }

                else if (Lex.Eq(tr.Name, "ZAxis"))
                {
                    view.ZAxisMx = AxisMx.DeserializeAxis("ZAxis", q, tr);
                }

                else if (Lex.Eq(tr.Name, "Axis"))
                {
                    ax = AxisMx.DeserializeAxis("Axis", q, tr);
                    view.AxesMx.Add(ax);
                }

                else if (Lex.Eq(tr.Name, "MarkerColor"))
                {
                    view.MarkerColor = ColorDimension.Deserialize("MarkerColor", q, tr);
                }

                else if (Lex.Eq(tr.Name, "MarkerSize"))
                {
                    view.MarkerSize = SizeDimension.Deserialize("MarkerSize", q, tr);
                }

                else if (Lex.Eq(tr.Name, "MarkerShape"))
                {
                    view.MarkerShape = ShapeDimension.Deserialize("MarkerShape", q, tr);
                }

                else if (Lex.Eq(tr.Name, "MarkerLabel"))
                {
                    view.MarkerLabel = LabelDimensionDef.Deserialize("MarkerLabel", q, tr);
                }

                else if (Lex.Eq(tr.Name, "Labels"))                 // obsolete label tag
                {
                    view.MarkerLabel = LabelDimensionDef.Deserialize("Labels", q, tr);
                }

                else if (Lex.Eq(tr.Name, "TooltipFields"))
                {
                    view.MarkerTooltip = TooltipDimensionDef.Deserialize("TooltipFields", q, tr);
                }

                else if (Lex.Eq(tr.Name, "Surface"))
                {
                    txt = tr.GetAttribute("FillMode");
                    if (txt != null)
                    {
                        view.SurfaceFillMode = (SurfaceFillMode)EnumUtil.Parse(typeof(SurfaceFillMode), txt);
                    }

                    XmlUtil.GetBoolAttribute(tr, "SmoothPalette", ref view.SmoothPalette);
                    XmlUtil.GetBoolAttribute(tr, "SmoothShading", ref view.SmoothShading);
                    XmlUtil.GetBoolAttribute(tr, "SemiTransparent", ref view.SemiTransparent);
                    XmlUtil.GetBoolAttribute(tr, "DrawFlat", ref view.DrawFlat);

                    txt = tr.GetAttribute("FrameMode");
                    if (txt != null)
                    {
                        view.SurfaceFrameMode = (SurfaceFrameMode)EnumUtil.Parse(typeof(SurfaceFrameMode), txt);
                    }

                    if (tr.IsEmptyElement)
                    {
                        continue;                                        // may be just attributes
                    }
                    tr.Read(); tr.MoveToContent();
                    if (!Lex.Eq(tr.Name, "Surface"))
                    {
                        throw new Exception("Expected Surface end element");
                    }
                }

                else if (Lex.Eq(tr.Name, "Trellis"))
                {
                    if (tr.IsEmptyElement)
                    {
                        continue;                                        // may be just attributes
                    }
                    XmlUtil.GetBoolAttribute(tr, "ByRowCol", ref view.TrellisByRowCol);

                    XmlUtil.GetBoolAttribute(tr, "Manual", ref view.TrellisManual);
                    XmlUtil.GetIntAttribute(tr, "MaxRows", ref view.TrellisMaxRows);
                    XmlUtil.GetIntAttribute(tr, "MaxCols", ref view.TrellisMaxCols);

                    while (true)
                    {
                        tr.Read(); tr.MoveToContent();

                        if (Lex.Eq(tr.Name, "ColumnQc"))
                        {
                            view.TrellisColQc = DeserializeQueryColumnRef(q, tr);
                        }

                        else if (Lex.Eq(tr.Name, "RowQc"))
                        {
                            view.TrellisRowQc = DeserializeQueryColumnRef(q, tr);
                        }

                        else if (Lex.Eq(tr.Name, "PageQc"))
                        {
                            view.TrellisPageQc = DeserializeQueryColumnRef(q, tr);
                        }

                        else if (Lex.Eq(tr.Name, "FlowQc"))
                        {
                            view.TrellisFlowQc = DeserializeQueryColumnRef(q, tr);
                        }

                        else if (tr.NodeType == XmlNodeType.EndElement &&                         // end of trellis definition
                                 Lex.Eq(tr.Name, "Trellis"))
                        {
                            break;
                        }

                        else
                        {
                            throw new Exception("Unexpected element: " + tr.Name);
                        }
                    }
                }

                else if (tr.NodeType == XmlNodeType.EndElement &&                 // end of chart props
                         Lex.Eq(tr.Name, "ChartProperties"))
                {
                    break;
                }

                else
                {
                    throw new Exception("Unexpected element: " + tr.Name);
                }
            }

            return(true);
        }