Esempio n. 1
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Hidden:
                    writer.Write(m_hidden);
                    break;

                case MemberName.Toggle:
                    writer.Write(m_toggle);
                    break;

                case MemberName.RecursiveReceiver:
                    writer.Write(m_recursiveReceiver);
                    break;

                case MemberName.ToggleSender:
                    writer.WriteReference(m_toggleSender);
                    break;

                case MemberName.RecursiveMember:
                    writer.WriteReference(m_recursiveMember);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(ChartMarker.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Type:
                    writer.Write(this.m_markerType);
                    break;

                case MemberName.Size:
                    writer.Write(this.m_markerSize);
                    break;

                case MemberName.ChartDataPoint:
                    writer.WriteReference(this.m_chartDataPoint);
                    break;

                case MemberName.ChartSeries:
                    writer.WriteReference(this.m_chartSeries);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Esempio n. 3
0
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapSpatialElement.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(this.m_map);
                    break;

                case MemberName.MapVectorLayer:
                    writer.WriteReference(this.m_mapVectorLayer);
                    break;

                case MemberName.VectorData:
                    writer.Write(this.m_vectorData);
                    break;

                case MemberName.MapFields:
                    writer.Write(this.m_mapFields);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ChartNoMoveDirections.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Chart:
                    writer.WriteReference(this.m_chart);
                    break;

                case MemberName.ChartSeries:
                    writer.WriteReference(this.m_chartSeries);
                    break;

                case MemberName.Up:
                    writer.Write(this.m_up);
                    break;

                case MemberName.Down:
                    writer.Write(this.m_down);
                    break;

                case MemberName.Left:
                    writer.Write(this.m_left);
                    break;

                case MemberName.Right:
                    writer.Write(this.m_right);
                    break;

                case MemberName.UpLeft:
                    writer.Write(this.m_upLeft);
                    break;

                case MemberName.UpRight:
                    writer.Write(this.m_upRight);
                    break;

                case MemberName.DownLeft:
                    writer.Write(this.m_downLeft);
                    break;

                case MemberName.DownRight:
                    writer.Write(this.m_downRight);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Visible:
                    writer.Write(m_visible);
                    break;

                case MemberName.Label:
                    writer.Write(m_label);
                    break;

                case MemberName.Position:
                    writer.Write(m_position);
                    break;

                case MemberName.Rotation:
                    writer.Write(m_rotation);
                    break;

                case MemberName.UseValueAsLabel:
                    writer.Write(m_useValueAsLabel);
                    break;

                case MemberName.Action:
                    writer.Write(m_action);
                    break;

                case MemberName.ChartDataPoint:
                    writer.WriteReference(m_chartDataPoint);
                    break;

                case MemberName.ChartSeries:
                    writer.WriteReference(m_chartSeries);
                    break;

                case MemberName.ToolTip:
                    writer.Write(m_toolTip);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Color:
                    writer.Write(m_color);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(m_exprHostID);
                    break;

                case MemberName.Chart:
                    writer.WriteReference(m_chart);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Esempio n. 7
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ChartElementPosition.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Top:
                    writer.Write(this.m_top);
                    break;

                case MemberName.Left:
                    writer.Write(this.m_left);
                    break;

                case MemberName.Height:
                    writer.Write(this.m_height);
                    break;

                case MemberName.Width:
                    writer.Write(this.m_width);
                    break;

                case MemberName.Chart:
                    writer.WriteReference(this.m_chart);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ChartAlignType.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Position:
                    writer.Write(this.m_position);
                    break;

                case MemberName.InnerPlotPosition:
                    writer.Write(this.m_innerPlotPosition);
                    break;

                case MemberName.AxesView:
                    writer.Write(this.m_axesView);
                    break;

                case MemberName.Cursor:
                    writer.Write(this.m_cursor);
                    break;

                case MemberName.Chart:
                    writer.WriteReference(this.m_chart);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Esempio n. 9
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapSize.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(this.m_map);
                    break;

                case MemberName.Width:
                    writer.Write(this.m_width);
                    break;

                case MemberName.Height:
                    writer.Write(this.m_height);
                    break;

                case MemberName.Unit:
                    writer.Write(this.m_unit);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Esempio n. 10
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapFieldDefinition.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(this.m_map);
                    break;

                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

                case MemberName.DataType:
                    writer.WriteEnum((int)this.m_dataType);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Esempio n. 11
0
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.JoinConditions:
                    writer.Write(m_joinConditions);
                    break;

                case MemberName.NaturalJoin:
                    writer.Write(m_naturalJoin);
                    break;

                case MemberName.RelatedDataSet:
                    writer.WriteReference(m_relatedDataSet);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Esempio n. 12
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(m_map);
                    break;

                case MemberName.Left:
                    writer.Write(m_left);
                    break;

                case MemberName.Top:
                    writer.Write(m_top);
                    break;

                case MemberName.Unit:
                    writer.Write(m_unit);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(BaseGaugeImage.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.GaugePanel:
                    writer.WriteReference(this.m_gaugePanel);
                    break;

                case MemberName.Source:
                    writer.Write(this.m_source);
                    break;

                case MemberName.Value:
                    writer.Write(this.m_value);
                    break;

                case MemberName.MIMEType:
                    writer.Write(this.m_MIMEType);
                    break;

                case MemberName.TransparentColor:
                    writer.Write(this.m_transparentColor);
                    break;
                }
            }
        }
Esempio n. 14
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(m_map);
                    break;

                case MemberName.Name:
                    writer.Write(m_name);
                    break;

                case MemberName.TileData:
                    writer.Write(m_tileData);
                    break;

                case MemberName.MIMEType:
                    writer.Write(m_mIMEType);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(m_exprHostID);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapFieldName.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(this.m_map);
                    break;

                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Esempio n. 16
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapLineRules.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(this.m_map);
                    break;

                case MemberName.MapSizeRule:
                    writer.Write(this.m_mapSizeRule);
                    break;

                case MemberName.MapColorRule:
                    writer.Write(this.m_mapColorRule);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Esempio n. 17
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(TextRun.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Value:
                    writer.Write(this.m_value);
                    break;

                case MemberName.ToolTip:
                    writer.Write(this.m_toolTip);
                    break;

                case MemberName.Style:
                    writer.Write(this.m_styleClass);
                    break;

                case MemberName.Label:
                    writer.Write(this.m_label);
                    break;

                case MemberName.MarkupType:
                    writer.Write(this.m_markupType);
                    break;

                case MemberName.Action:
                    writer.Write(this.m_action);
                    break;

                case MemberName.DataType:
                    writer.WriteEnum((int)this.m_constantDataType);
                    break;

                case MemberName.IndexInCollection:
                    writer.Write(this.m_indexInCollection);
                    break;

                case MemberName.Paragraph:
                    writer.WriteReference(this.m_paragraph);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

                case MemberName.ValueReferenced:
                    writer.Write(this.m_valueReferenced);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Action:
                    writer.Write(m_action);
                    break;

                case MemberName.ID:
                    writer.Write(m_id);
                    break;

                case MemberName.Hidden:
                    writer.Write(m_hidden);
                    break;

                case MemberName.OffsetX:
                    writer.Write(m_offsetX);
                    break;

                case MemberName.OffsetY:
                    writer.Write(m_offsetY);
                    break;

                case MemberName.Label:
                    writer.Write(m_label);
                    break;

                case MemberName.ToolTip:
                    writer.Write(m_toolTip);
                    break;

                case MemberName.MapVectorLayer:
                    writer.WriteReference(m_mapVectorLayer);
                    break;

                case MemberName.DataElementLabel:
                    writer.Write(m_dataElementLabel);
                    break;

                case MemberName.DataElementName:
                    writer.Write(m_dataElementName);
                    break;

                case MemberName.DataElementOutput:
                    writer.WriteEnum((int)m_dataElementOutput);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Esempio n. 19
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Parameters:
                    writer.Write(m_parameters);
                    break;

                case MemberName.NoRowsMessage:
                    writer.Write(m_noRowsMessage);
                    break;

                case MemberName.MergeTransactions:
                    writer.Write(m_mergeTransactions);
                    break;

                case MemberName.ContainingScopes:
                    writer.WriteListOfReferences(m_containingScopes);
                    break;

                case MemberName.IsTablixCellScope:
                    writer.Write(m_isTablixCellScope);
                    break;

                case MemberName.ReportName:
                    writer.Write(m_reportName);
                    break;

                case MemberName.OmitBorderOnPageBreak:
                    writer.Write(m_omitBorderOnPageBreak);
                    break;

                case MemberName.KeepTogether:
                    writer.Write(m_keepTogether);
                    break;

                case MemberName.Location:
                    writer.WriteEnum((int)m_location);
                    break;

                case MemberName.IndexInCollection:
                    writer.Write(m_indexInCollection);
                    break;

                case MemberName.ContainingSection:
                    writer.WriteReference(m_containingSection);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Esempio n. 20
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ChartThreeDProperties.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Enabled:
                    writer.Write(this.m_enabled);
                    break;

                case MemberName.ProjectionMode:
                    writer.Write(this.m_projectionMode);
                    break;

                case MemberName.Rotation:
                    writer.Write(this.m_rotation);
                    break;

                case MemberName.Inclination:
                    writer.Write(this.m_inclination);
                    break;

                case MemberName.Perspective:
                    writer.Write(this.m_perspective);
                    break;

                case MemberName.DepthRatio:
                    writer.Write(this.m_depthRatio);
                    break;

                case MemberName.Shading:
                    writer.Write(this.m_shading);
                    break;

                case MemberName.GapDepth:
                    writer.Write(this.m_gapDepth);
                    break;

                case MemberName.WallThickness:
                    writer.Write(this.m_wallThickness);
                    break;

                case MemberName.Clustered:
                    writer.Write(this.m_clustered);
                    break;

                case MemberName.Chart:
                    writer.WriteReference(this.m_chart);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Esempio n. 21
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.AggregatesSpanGroupFilter:
                    writer.Write(m_aggregatesSpanGroupFilter);
                    break;

                case MemberName.AggregatesOfAggregates:
                    writer.Write(m_aggregatesOfAggregates);
                    break;

                case MemberName.PostSortAggregatesOfAggregates:
                    writer.Write(m_postSortAggregatesOfAggregates);
                    break;

                case MemberName.RunningValuesOfAggregates:
                    writer.Write(m_runningValuesOfAggregates);
                    break;

                case MemberName.ScopeID:
                    writer.Write(m_scopeID);
                    break;

                case MemberName.HasAggregatesToUpdateAtRowScope:
                    writer.Write(m_hasAggregatesToUpdateAtRowScope);
                    break;

                case MemberName.IsDecomposable:
                    writer.Write(m_isDecomposable);
                    break;

                case MemberName.DataSet:
                    writer.WriteReference(m_dataSet);
                    break;

                case MemberName.JoinInfo:
                    writer.Write(m_joinInfo);
                    break;

                case MemberName.DataPipelineID:
                    writer.Write(m_dataPipelineID);
                    break;

                case MemberName.GroupingFieldIndicesForServerAggregates:
                    writer.WriteListOfPrimitives(m_groupingFieldIndicesForServerAggregates);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ChartItemInLegend.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Chart:
                    writer.WriteReference(this.m_chart);
                    break;

                case MemberName.ChartSeries:
                    writer.WriteReference(this.m_chartSeries);
                    break;

                case MemberName.ChartDataPoint:
                    writer.WriteReference(this.m_chartDataPoint);
                    break;

                case MemberName.Action:
                    writer.Write(this.m_action);
                    break;

                case MemberName.LegendText:
                    writer.Write(this.m_legendText);
                    break;

                case MemberName.ToolTip:
                    writer.Write(this.m_toolTip);
                    break;

                case MemberName.Hidden:
                    writer.Write(this.m_hidden);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(m_map);
                    break;

                case MemberName.MapVectorLayer:
                    writer.WriteReference(m_mapVectorLayer);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.GaugePanel:
                    writer.WriteReference(m_gaugePanel);
                    break;

                case MemberName.Value:
                    writer.Write(m_value);
                    break;

                case MemberName.Formula:
                    writer.Write(m_formula);
                    break;

                case MemberName.MinPercent:
                    writer.Write(m_minPercent);
                    break;

                case MemberName.MaxPercent:
                    writer.Write(m_maxPercent);
                    break;

                case MemberName.Multiplier:
                    writer.Write(m_multiplier);
                    break;

                case MemberName.AddConstant:
                    writer.Write(m_addConstant);
                    break;

                case MemberName.DataElementName:
                    writer.Write(m_dataElementName);
                    break;

                case MemberName.DataElementOutput:
                    writer.WriteEnum((int)m_dataElementOutput);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(m_exprHostID);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Esempio n. 25
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.RowParentDataSet:
                    writer.WriteReference(m_rowParentDataSet);
                    break;

                case MemberName.ColumnParentDataSet:
                    writer.WriteReference(m_columnParentDataSet);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(CustomReportItem.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.DataColumnMembers:
                    writer.Write(this.m_dataColumnMembers);
                    break;

                case MemberName.DataRowMembers:
                    writer.Write(this.m_dataRowMembers);
                    break;

                case MemberName.DataRows:
                    writer.Write(this.m_dataRows);
                    break;

                case MemberName.Type:
                    writer.Write(this.m_type);
                    break;

                case MemberName.AltReportItem:
                    writer.WriteReference(this.m_altReportItem);
                    break;

                case MemberName.AltReportItemIndexInParentCollectionDef:
                    writer.Write(this.m_altReportItemIndexInParentCollectionDef);
                    break;

                case MemberName.RenderReportItemColDef:
                    writer.Write(this.m_renderReportItem);
                    break;

                case MemberName.ExplicitAltReportItem:
                    writer.Write(this.m_explicitAltReportItemDefined);
                    break;

                case MemberName.IsDataRegion:
                    writer.Write(this.m_isDataRegion);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ChartFormulaParameter.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

                case MemberName.Value:
                    writer.Write(this.m_value);
                    break;

                case MemberName.Source:
                    writer.Write(this.m_source);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

                case MemberName.Chart:
                    writer.WriteReference(this.m_chart);
                    break;

                case MemberName.SourceSeries:
                    writer.WriteReference(this.SourceSeries);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Esempio n. 28
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapBindingFieldPair.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(this.m_map);
                    break;

                case MemberName.MapVectorLayer:
                    writer.WriteReference(this.m_mapVectorLayer);
                    break;

                case MemberName.FieldName:
                    writer.Write(this.m_fieldName);
                    break;

                case MemberName.BindingExpression:
                    writer.Write(this.m_bindingExpression);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

                case MemberName.ExprHostMapMemberID:
                    writer.Write(this.m_exprHostMapMemberID);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Esempio n. 29
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(EndUserSort.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.DataSet:
                    writer.WriteReference(this.m_dataSet);
                    break;

                case MemberName.SortExpressionScope:
                    writer.WriteReference(this.m_sortExpressionScope);
                    break;

                case MemberName.GroupsInSortTarget:
                    writer.WriteListOfReferences(this.m_groupsInSortTarget);
                    break;

                case MemberName.SortTarget:
                    writer.WriteReference(this.m_sortTarget);
                    break;

                case MemberName.SortExpressionIndex:
                    writer.Write(this.m_sortExpressionIndex);
                    break;

                case MemberName.DetailScopeSubReports:
                    writer.WriteListOfReferences(this.m_detailScopeSubReports);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(IndicatorState.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.GaugePanel:
                    writer.WriteReference(this.m_gaugePanel);
                    break;

                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

                case MemberName.StartValue:
                    writer.Write(this.m_startValue);
                    break;

                case MemberName.EndValue:
                    writer.Write(this.m_endValue);
                    break;

                case MemberName.Color:
                    writer.Write(this.m_color);
                    break;

                case MemberName.ScaleFactor:
                    writer.Write(this.m_scaleFactor);
                    break;

                case MemberName.IndicatorStyle:
                    writer.Write(this.m_indicatorStyle);
                    break;

                case MemberName.IndicatorImage:
                    writer.Write(this.m_indicatorImage);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }