Beispiel #1
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(m_name);
                    break;

                case MemberName.Fields:
                    writer.Write(m_fields);
                    break;

                case MemberName.Query:
                    writer.Write(m_query);
                    break;

                case MemberName.SharedDataSetQuery:
                    writer.Write(m_sharedDataSetQuery);
                    break;

                case MemberName.Collation:
                    writer.Write(m_collation);
                    break;

                case MemberName.CollationCulture:
                    writer.Write(m_collationCulture);
                    break;

                case MemberName.LCID:
                    writer.Write(m_lcid);
                    break;

                case MemberName.CaseSensitivity:
                    writer.WriteEnum((int)m_caseSensitivity);
                    break;

                case MemberName.AccentSensitivity:
                    writer.WriteEnum((int)m_accentSensitivity);
                    break;

                case MemberName.KanatypeSensitivity:
                    writer.WriteEnum((int)m_kanatypeSensitivity);
                    break;

                case MemberName.WidthSensitivity:
                    writer.WriteEnum((int)m_widthSensitivity);
                    break;

                case MemberName.Filters:
                    writer.Write(m_filters);
                    break;

                case MemberName.InterpretSubtotalsAsDetails:
                    writer.WriteEnum((int)m_interpretSubtotalsAsDetails);
                    break;

                case MemberName.CatalogID:
                    writer.Write(m_catalogID);
                    break;

                case MemberName.NonCalculatedFieldCount:
                    writer.Write(m_nonCalculatedFieldCount);
                    break;

                case MemberName.CompiledCode:
                    writer.Write(m_compiledCode);
                    break;

                case MemberName.CompiledCodeGeneratedWithRefusedPermissions:
                    writer.Write(m_compiledCodeGeneratedWithRefusedPermissions);
                    break;

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

                case MemberName.ExprHostAssemblyID:
                    writer.Write(m_exprHostAssemblyId);
                    break;

                case MemberName.NullsAsBlanks:
                    writer.Write(m_nullsAsBlanks);
                    break;

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

                case MemberName.Report:
                    Global.Tracer.Assert(m_report != null);
                    writer.WriteReference(m_report);
                    break;

                case MemberName.HasDocumentMap:
                    writer.Write(m_hasDocumentMap);
                    break;

                case MemberName.HasShowHide:
                    writer.Write(m_hasShowHide);
                    break;

                case MemberName.HasBookmarks:
                    writer.Write(m_hasBookmarks);
                    break;

                case MemberName.RequestUserName:
                    writer.Write(m_requestUserName);
                    break;

                case MemberName.ReportServerUrl:
                    writer.Write(m_reportServerUrl);
                    break;

                case MemberName.ReportFolder:
                    writer.Write(m_reportFolder);
                    break;

                case MemberName.Language:
                    writer.Write(m_language);
                    break;

                case MemberName.ProcessingMessages:
                    writer.Write(m_processingMessages);
                    break;

                case MemberName.Parameters:
                    writer.Write((ArrayList)null);
                    break;

                case MemberName.ImageChunkNames:
                    writer.WriteStringStringHashtable(m_cachedDatabaseImages);
                    break;

                case MemberName.GeneratedReportItemChunkNames:
                    writer.WriteStringStringHashtable(m_cachedGeneratedReportItems);
                    break;

                case MemberName.HasUserSortFilter:
                    writer.Write(m_hasUserSortFilter);
                    break;

                case MemberName.AggregateFieldReferences:
                    writer.WriteStringListOfStringDictionary(m_aggregateFieldReferences);
                    break;

                case MemberName.SnapshotParameters:
                    writer.Write((IPersistable)m_parameters);
                    break;

                case MemberName.DefinitionHasDocumentMap:
                    writer.Write(m_definitionHasDocumentMap);
                    break;

                case MemberName.DocumentMapRenderFormat:
                    writer.Write(m_documentMapRenderFormat);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        void IPersistable.Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ActionInstance.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Label:
                {
                    string value2 = null;
                    if (this.m_actionDef.Label.IsExpression)
                    {
                        value2 = this.m_label;
                    }
                    writer.Write(value2);
                    break;
                }

                case MemberName.BookmarkLink:
                {
                    string value = null;
                    if (this.m_actionDef.BookmarkLink != null && this.m_actionDef.BookmarkLink.IsExpression)
                    {
                        value = this.m_bookmark;
                    }
                    writer.Write(value);
                    break;
                }

                case MemberName.HyperLinkURL:
                {
                    string value3 = null;
                    if (this.m_actionDef.Hyperlink != null && this.m_actionDef.Hyperlink.IsExpression)
                    {
                        value3 = this.m_hyperlinkText;
                    }
                    writer.Write(value3);
                    break;
                }

                case MemberName.DrillthroughReportName:
                {
                    string value4 = null;
                    if (this.m_actionDef.Drillthrough != null && this.m_actionDef.Drillthrough.ReportName.IsExpression)
                    {
                        value4 = this.m_actionDef.Drillthrough.Instance.ReportName;
                    }
                    writer.Write(value4);
                    break;
                }

                case MemberName.DrillthroughParameters:
                {
                    ParameterInstance[] array = null;
                    if (this.m_actionDef.Drillthrough != null && this.m_actionDef.Drillthrough.Parameters != null)
                    {
                        array = new ParameterInstance[this.m_actionDef.Drillthrough.Parameters.Count];
                        for (int i = 0; i < array.Length; i++)
                        {
                            array[i] = ((ReportElementCollectionBase <Parameter>) this.m_actionDef.Drillthrough.Parameters)[i].Instance;
                        }
                    }
                    writer.Write((IPersistable[])array);
                    break;
                }

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #4
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(m_name);
                    break;

                case MemberName.ChartDataPoints:
                    writer.Write(m_dataPoints);
                    break;

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

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

                case MemberName.ChartMember:
                    writer.WriteReference(ParentChartMember);
                    break;

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

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

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

                case MemberName.Subtype:
                    writer.Write(m_subtype);
                    break;

                case MemberName.EmptyPoints:
                    writer.Write(m_emptyPoints);
                    break;

                case MemberName.LegendName:
                    writer.Write(m_legendName);
                    break;

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

                case MemberName.ChartAreaName:
                    writer.Write(m_chartAreaName);
                    break;

                case MemberName.ValueAxisName:
                    writer.Write(m_valueAxisName);
                    break;

                case MemberName.CategoryAxisName:
                    writer.Write(m_categoryAxisName);
                    break;

                case MemberName.StyleClass:
                    writer.Write(m_styleClass);
                    break;

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

                case MemberName.HideInLegend:
                    writer.Write(m_hideInLegend);
                    break;

                case MemberName.ChartSmartLabel:
                    writer.Write(m_chartSmartLabel);
                    break;

                case MemberName.CustomProperties:
                    writer.Write(m_customProperties);
                    break;

                case MemberName.DataLabel:
                    writer.Write(m_dataLabel);
                    break;

                case MemberName.Marker:
                    writer.Write(m_marker);
                    break;

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

                case MemberName.ChartItemInLegend:
                    writer.Write(m_chartItemInLegend);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #5
0
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapAppearanceRule.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.DataValue:
                    writer.Write(this.m_dataValue);
                    break;

                case MemberName.DistributionType:
                    writer.Write(this.m_distributionType);
                    break;

                case MemberName.BucketCount:
                    writer.Write(this.m_bucketCount);
                    break;

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

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

                case MemberName.MapBuckets:
                    writer.Write(this.m_mapBuckets);
                    break;

                case MemberName.LegendName:
                    writer.Write(this.m_legendName);
                    break;

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

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

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

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

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

                case MemberName.GaugeInputValue:
                    writer.Write(this.m_gaugeInputValue);
                    break;

                case MemberName.BarStart:
                    writer.Write(this.m_barStart);
                    break;

                case MemberName.DistanceFromScale:
                    writer.Write(this.m_distanceFromScale);
                    break;

                case MemberName.PointerImage:
                    writer.Write(this.m_pointerImage);
                    break;

                case MemberName.MarkerLength:
                    writer.Write(this.m_markerLength);
                    break;

                case MemberName.MarkerStyle:
                    writer.Write(this.m_markerStyle);
                    break;

                case MemberName.Placement:
                    writer.Write(this.m_placement);
                    break;

                case MemberName.SnappingEnabled:
                    writer.Write(this.m_snappingEnabled);
                    break;

                case MemberName.SnappingInterval:
                    writer.Write(this.m_snappingInterval);
                    break;

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

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

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

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

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

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #7
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(ChartArea.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

                case MemberName.CategoryAxes:
                    writer.Write(this.m_categoryAxes);
                    break;

                case MemberName.ValueAxes:
                    writer.Write(this.m_valueAxes);
                    break;

                case MemberName.ThreeDProperties:
                    writer.Write(this.m_3dProperties);
                    break;

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

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

                case MemberName.AlignOrientation:
                    writer.Write(this.m_alignOrientation);
                    break;

                case MemberName.ChartAlignType:
                    writer.Write(this.m_chartAlignType);
                    break;

                case MemberName.AlignWithChartArea:
                    writer.Write(this.m_alignWithChartArea);
                    break;

                case MemberName.EquallySizedAxesFont:
                    writer.Write(this.m_equallySizedAxesFont);
                    break;

                case MemberName.ChartElementPosition:
                    writer.Write(this.m_chartElementPosition);
                    break;

                case MemberName.ChartInnerPlotPosition:
                    writer.Write(this.m_chartInnerPlotPosition);
                    break;

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

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

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

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

                case MemberName.Docking:
                    writer.Write(this.m_docking);
                    break;

                case MemberName.DockToChartArea:
                    writer.Write(this.m_dockToChartArea);
                    break;

                case MemberName.DockOutsideChartArea:
                    writer.Write(this.m_dockOutsideChartArea);
                    break;

                case MemberName.DockOffset:
                    writer.Write(this.m_dockOffset);
                    break;

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

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

                case MemberName.TextOrientation:
                    writer.Write(this.m_textOrientation);
                    break;

                case MemberName.ChartElementPosition:
                    writer.Write(this.m_chartElementPosition);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #9
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.InnerGroupings:
                    writer.Write(m_innerGroupings);
                    break;

                case MemberName.CellRunningValues:
                    writer.WriteListOfPrimitives(m_cellRVs);
                    break;

                case MemberName.StaticCellRunningValues:
                    writer.WriteListOfPrimitives(m_staticCellRVs);
                    break;

                case MemberName.CellPreviousValues:
                    writer.WriteListOfPrimitives(m_cellPreviousValues);
                    break;

                case MemberName.StaticCellPreviousValues:
                    writer.WriteListOfPrimitives(m_staticCellPreviousValues);
                    break;

                case MemberName.HeadingLevel:
                    writer.Write(m_headingLevel);
                    break;

                case MemberName.OutermostStatics:
                    writer.Write(m_outermostStatics);
                    break;

                case MemberName.HasLeafCells:
                    writer.Write(m_hasLeafCells);
                    break;

                case MemberName.ProcessOutermostStaticCells:
                    writer.Write(m_processOutermostStaticCells);
                    break;

                case MemberName.CurrentMemberIndexWithinScopeLevel:
                    writer.Write(m_currentMemberIndexWithinScopeLevel);
                    break;

                case MemberName.RecursiveParentIndexes:
                    writer.WriteListOfPrimitives(m_recursiveParentIndexes);
                    break;

                case MemberName.ProcessStaticCellsForRVs:
                    writer.Write(m_processStaticCellsForRVs);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #10
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(m_name);
                    break;

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

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

                case MemberName.Layout:
                    writer.Write(m_layout);
                    break;

                case MemberName.DockToChartArea:
                    writer.Write(m_dockToChartArea);
                    break;

                case MemberName.DockOutsideChartArea:
                    writer.Write(m_dockOutsideChartArea);
                    break;

                case MemberName.ChartLegendTitle:
                    writer.Write(m_chartLegendTitle);
                    break;

                case MemberName.AutoFitTextDisabled:
                    writer.Write(m_autoFitTextDisabled);
                    break;

                case MemberName.MinFontSize:
                    writer.Write(m_minFontSize);
                    break;

                case MemberName.HeaderSeparator:
                    writer.Write(m_headerSeparator);
                    break;

                case MemberName.HeaderSeparatorColor:
                    writer.Write(m_headerSeparatorColor);
                    break;

                case MemberName.ColumnSeparator:
                    writer.Write(m_columnSeparator);
                    break;

                case MemberName.ColumnSeparatorColor:
                    writer.Write(m_columnSeparatorColor);
                    break;

                case MemberName.ColumnSpacing:
                    writer.Write(m_columnSpacing);
                    break;

                case MemberName.InterlacedRows:
                    writer.Write(m_interlacedRows);
                    break;

                case MemberName.InterlacedRowsColor:
                    writer.Write(m_interlacedRowsColor);
                    break;

                case MemberName.EquallySpacedItems:
                    writer.Write(m_equallySpacedItems);
                    break;

                case MemberName.Reversed:
                    writer.Write(m_reversed);
                    break;

                case MemberName.MaxAutoSize:
                    writer.Write(m_maxAutoSize);
                    break;

                case MemberName.TextWrapThreshold:
                    writer.Write(m_textWrapThreshold);
                    break;

                case MemberName.ChartLegendColumns:
                    writer.Write(m_chartLegendColumns);
                    break;

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

                case MemberName.ChartLegendCustomItems:
                    writer.Write(m_chartLegendCustomItems);
                    break;

                case MemberName.ChartElementPosition:
                    writer.Write(m_chartElementPosition);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #11
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(Map.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.MapDataRegions:
                    writer.Write(this.m_mapDataRegions);
                    break;

                case MemberName.MapViewport:
                    writer.Write(this.m_mapViewport);
                    break;

                case MemberName.MapLayers:
                    writer.Write(this.m_mapLayers);
                    break;

                case MemberName.MapLegends:
                    writer.Write(this.m_mapLegends);
                    break;

                case MemberName.MapTitles:
                    writer.Write(this.m_mapTitles);
                    break;

                case MemberName.MapDistanceScale:
                    writer.Write(this.m_mapDistanceScale);
                    break;

                case MemberName.MapColorScale:
                    writer.Write(this.m_mapColorScale);
                    break;

                case MemberName.MapBorderSkin:
                    writer.Write(this.m_mapBorderSkin);
                    break;

                case MemberName.AntiAliasing:
                    writer.Write(this.m_antiAliasing);
                    break;

                case MemberName.TextAntiAliasingQuality:
                    writer.Write(this.m_textAntiAliasingQuality);
                    break;

                case MemberName.ShadowIntensity:
                    writer.Write(this.m_shadowIntensity);
                    break;

                case MemberName.MaximumSpatialElementCount:
                    writer.Write(this.m_maximumSpatialElementCount);
                    break;

                case MemberName.MaximumTotalPointCount:
                    writer.Write(this.m_maximumTotalPointCount);
                    break;

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

                case MemberName.TileLanguage:
                    writer.Write(this.m_tileLanguage);
                    break;

                case MemberName.PageBreak:
                    writer.Write(this.m_pageBreak);
                    break;

                case MemberName.PageName:
                    writer.Write(this.m_pageName);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #12
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.CategoryMembers:
                    writer.Write(m_categoryMembers);
                    break;

                case MemberName.SeriesMembers:
                    writer.Write(m_seriesMembers);
                    break;

                case MemberName.ChartSeriesCollection:
                    writer.Write(m_chartSeriesCollection);
                    break;

                case MemberName.ChartDerivedSeriesCollection:
                    writer.Write(m_chartDerivedSeriesCollection);
                    break;

                case MemberName.Palette:
                    writer.Write(m_palette);
                    break;

                case MemberName.ChartAreas:
                    writer.Write(m_chartAreas);
                    break;

                case MemberName.Titles:
                    writer.Write(m_titles);
                    break;

                case MemberName.ChartLegends:
                    writer.Write(m_legends);
                    break;

                case MemberName.NoDataMessage:
                    writer.Write(m_noDataMessage);
                    break;

                case MemberName.BorderSkin:
                    writer.Write(m_borderSkin);
                    break;

                case MemberName.DynamicHeight:
                    writer.Write(m_dynamicHeight);
                    break;

                case MemberName.DynamicWidth:
                    writer.Write(m_dynamicWidth);
                    break;

                case MemberName.CodeParameters:
                    writer.Write(m_codeParameters);
                    break;

                case MemberName.CustomPaletteColors:
                    writer.Write(m_customPaletteColors);
                    break;

                case MemberName.DataValueSequenceRendering:
                    writer.Write(m_dataValueSequenceRendering);
                    break;

                case MemberName.PaletteHatchBehavior:
                    writer.Write(m_paletteHatchBehavior);
                    break;

                case MemberName.ColumnGroupingIsSwitched:
                    writer.Write(m_columnGroupingIsSwitched);
                    break;

                case MemberName.EnableCategoryDrilldown:
                    writer.Write(m_enableCategoryDrilldown);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #13
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;

            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.HierarchyDef:
                {
                    int value2 = scalabilityCache.StoreStaticReference(m_hierarchyDef);
                    writer.Write(value2);
                    break;
                }

                case MemberName.OuterScope:
                    writer.Write(m_outerScope);
                    break;

                case MemberName.ProcessingStage:
                    writer.WriteEnum((int)m_processingStage);
                    break;

                case MemberName.ScopedRunningValues:
                    writer.WriteListOfPrimitives(m_scopedRunningValues);
                    break;

                case MemberName.RunningValuesInGroup:
                    writer.WriteListOfPrimitives(m_runningValuesInGroup);
                    break;

                case MemberName.PreviousValuesInGroup:
                    writer.WriteListOfPrimitives(m_previousValuesInGroup);
                    break;

                case MemberName.GroupCollection:
                    writer.WriteStringRIFObjectDictionary(m_groupCollection);
                    break;

                case MemberName.DataAction:
                    writer.WriteEnum((int)m_dataAction);
                    break;

                case MemberName.OuterDataAction:
                    writer.WriteEnum((int)m_outerDataAction);
                    break;

                case MemberName.GroupingType:
                    writer.WriteEnum((int)m_groupingType);
                    break;

                case MemberName.Filters:
                {
                    int value = scalabilityCache.StoreStaticReference(m_groupFilters);
                    writer.Write(value);
                    break;
                }

                case MemberName.ParentExpression:
                    writer.Write(m_parentExpression);
                    break;

                case MemberName.CurrentGroupExprValue:
                    writer.Write(m_currentGroupExprValue);
                    break;

                case MemberName.SaveGroupExprValues:
                    writer.Write(m_saveGroupExprValues);
                    break;

                case MemberName.SortFilterExpressionScopeInfoIndices:
                    writer.Write(m_sortFilterExpressionScopeInfoIndices);
                    break;

                case MemberName.BuiltinSortOverridden:
                    writer.Write(m_builtinSortOverridden);
                    break;

                case MemberName.IsDetailGroup:
                    writer.Write(m_isDetailGroup);
                    break;

                case MemberName.DetailUserSortTargetInfo:
                    writer.Write(m_detailUserSortTargetInfo);
                    break;

                case MemberName.DetailRows:
                    writer.Write(m_detailDataRows);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #14
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.X:
                    writer.Write(m_x);
                    break;

                case MemberName.Y:
                    writer.Write(m_y);
                    break;

                case MemberName.Size:
                    writer.Write(m_size);
                    break;

                case MemberName.High:
                    writer.Write(m_high);
                    break;

                case MemberName.Low:
                    writer.Write(m_low);
                    break;

                case MemberName.Start:
                    writer.Write(m_start);
                    break;

                case MemberName.End:
                    writer.Write(m_end);
                    break;

                case MemberName.Mean:
                    writer.Write(m_mean);
                    break;

                case MemberName.Median:
                    writer.Write(m_median);
                    break;

                case MemberName.HighlightX:
                    writer.Write(m_highlightX);
                    break;

                case MemberName.HighlightY:
                    writer.Write(m_highlightY);
                    break;

                case MemberName.HighlightSize:
                    writer.Write(m_highlightSize);
                    break;

                case MemberName.FormatX:
                    writer.Write(m_formatX);
                    break;

                case MemberName.FormatY:
                    writer.Write(m_formatY);
                    break;

                case MemberName.FormatSize:
                    writer.Write(m_formatSize);
                    break;

                case MemberName.CurrencyLanguageX:
                    writer.Write(m_currencyLanguageX);
                    break;

                case MemberName.CurrencyLanguageY:
                    writer.Write(m_currencyLanguageY);
                    break;

                case MemberName.CurrencyLanguageSize:
                    writer.Write(m_currencyLanguageSize);
                    break;

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

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #15
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.MapCoordinateSystem:
                    writer.Write(m_mapCoordinateSystem);
                    break;

                case MemberName.MapProjection:
                    writer.Write(m_mapProjection);
                    break;

                case MemberName.ProjectionCenterX:
                    writer.Write(m_projectionCenterX);
                    break;

                case MemberName.ProjectionCenterY:
                    writer.Write(m_projectionCenterY);
                    break;

                case MemberName.MapLimits:
                    writer.Write(m_mapLimits);
                    break;

                case MemberName.MapView:
                    writer.Write(m_mapView);
                    break;

                case MemberName.MaximumZoom:
                    writer.Write(m_maximumZoom);
                    break;

                case MemberName.MinimumZoom:
                    writer.Write(m_minimumZoom);
                    break;

                case MemberName.ContentMargin:
                    writer.Write(m_contentMargin);
                    break;

                case MemberName.MapMeridians:
                    writer.Write(m_mapMeridians);
                    break;

                case MemberName.MapParallels:
                    writer.Write(m_mapParallels);
                    break;

                case MemberName.GridUnderContent:
                    writer.Write(m_gridUnderContent);
                    break;

                case MemberName.SimplificationResolution:
                    writer.Write(m_simplificationResolution);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #16
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_declaration);
            IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;

            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.TextRuns:
                    writer.Write(m_textRuns);
                    break;

                case MemberName.Style:
                    writer.WriteByteVariantHashtable(m_styles);
                    break;

                case MemberName.ListStyle:
                    writer.Write((byte?)m_listStyle);
                    break;

                case MemberName.ListLevel:
                    writer.Write(m_listLevel);
                    break;

                case MemberName.ParagraphNumber:
                    writer.Write(m_paragraphNumber);
                    break;

                case MemberName.SpaceBefore:
                    Utility.WriteReportSize(writer, m_spaceBefore);
                    break;

                case MemberName.SpaceAfter:
                    Utility.WriteReportSize(writer, m_spaceAfter);
                    break;

                case MemberName.LeftIndent:
                    Utility.WriteReportSize(writer, m_leftIndent);
                    break;

                case MemberName.RightIndent:
                    Utility.WriteReportSize(writer, m_rightIndent);
                    break;

                case MemberName.HangingIndent:
                    Utility.WriteReportSize(writer, m_hangingIndent);
                    break;

                case MemberName.FirstLine:
                    writer.Write(m_firstLine);
                    break;

                case MemberName.UniqueName:
                    writer.Write(m_uniqueName);
                    break;

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

                default:
                    RSTrace.RenderingTracer.Assert(condition: false, string.Empty);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(m_name);
                    break;

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

                case MemberName.GroupExpressions:
                    writer.Write(m_groupExpressions);
                    break;

                case MemberName.GroupLabel:
                    writer.Write(m_groupLabel);
                    break;

                case MemberName.SortDirections:
                    writer.WriteListOfPrimitives(m_sortDirections);
                    break;

                case MemberName.Aggregates:
                    writer.Write(m_aggregates);
                    break;

                case MemberName.GroupAndSort:
                    writer.Write(m_groupAndSort);
                    break;

                case MemberName.Filters:
                    writer.Write(m_filters);
                    break;

                case MemberName.ReportItemsWithHideDuplicates:
                    writer.WriteListOfReferences(m_reportItemsWithHideDuplicates);
                    break;

                case MemberName.Parent:
                    writer.Write(m_parent);
                    break;

                case MemberName.RecursiveAggregates:
                    writer.Write(m_recursiveAggregates);
                    break;

                case MemberName.PostSortAggregates:
                    writer.Write(m_postSortAggregates);
                    break;

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

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

                case MemberName.SaveGroupExprValues:
                    writer.Write(m_saveGroupExprValues);
                    break;

                case MemberName.UserSortExpressions:
                    writer.Write(m_userSortExpressions);
                    break;

                case MemberName.NonDetailSortFiltersInScope:
                    writer.WriteInt32PrimitiveListHashtable <int>(m_nonDetailSortFiltersInScope);
                    break;

                case MemberName.DetailSortFiltersInScope:
                    writer.WriteInt32PrimitiveListHashtable <int>(m_detailSortFiltersInScope);
                    break;

                case MemberName.Variables:
                    writer.Write(m_variables);
                    break;

                case MemberName.PageBreak:
                    writer.Write(m_pageBreak);
                    break;

                case MemberName.PageName:
                    writer.Write(m_pageName);
                    break;

                case MemberName.DomainScope:
                    writer.Write(m_domainScope);
                    break;

                case MemberName.ScopeIDForDomainScope:
                    writer.Write(m_scopeIDForDomainScope);
                    break;

                case MemberName.NaturalGroup:
                    writer.Write(m_naturalGroup);
                    break;

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

                case MemberName.CanScrollVertically:
                    writer.Write(this.m_canScrollVertically);
                    break;

                case MemberName.CanGrow:
                    writer.Write(this.m_canGrow);
                    break;

                case MemberName.CanShrink:
                    writer.Write(this.m_canShrink);
                    break;

                case MemberName.HideDuplicates:
                    writer.Write(this.m_hideDuplicates);
                    break;

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

                case MemberName.IsToggle:
                    writer.Write(this.m_isToggle);
                    break;

                case MemberName.InitialToggleState:
                    writer.Write(this.m_initialToggleState);
                    break;

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

                case MemberName.TextRunValueReferenced:
                    writer.Write(this.m_textRunValueReferenced);
                    break;

                case MemberName.RecursiveSender:
                    writer.Write(this.m_recursiveSender);
                    break;

                case MemberName.DataElementStyleAttribute:
                    writer.Write(this.m_dataElementStyleAttribute);
                    break;

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

                case MemberName.UserSort:
                    writer.Write(this.m_userSort);
                    break;

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

                case MemberName.IsSubReportTopLevelScope:
                    writer.Write(this.m_isSubReportTopLevelScope);
                    break;

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

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

                case MemberName.SequenceID:
                    writer.Write(this.m_sequenceID);
                    break;

                case MemberName.HasExpressionBasedValue:
                    writer.Write(this.m_hasExpressionBasedValue);
                    break;

                case MemberName.HasValue:
                    writer.Write(this.m_hasValue);
                    break;

                case MemberName.IsSimple:
                    writer.Write(this.m_isSimple);
                    break;

                case MemberName.HasNonRecursiveSender:
                    writer.Write(this.m_hasNonRecursiveSender);
                    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.LinearGauges:
                    writer.Write(m_linearGauges);
                    break;

                case MemberName.RadialGauges:
                    writer.Write(m_radialGauges);
                    break;

                case MemberName.NumericIndicators:
                    writer.Write(m_numericIndicators);
                    break;

                case MemberName.StateIndicators:
                    writer.Write(m_stateIndicators);
                    break;

                case MemberName.GaugeImages:
                    writer.Write(m_gaugeImages);
                    break;

                case MemberName.GaugeLabels:
                    writer.Write(m_gaugeLabels);
                    break;

                case MemberName.AntiAliasing:
                    writer.Write(m_antiAliasing);
                    break;

                case MemberName.AutoLayout:
                    writer.Write(m_autoLayout);
                    break;

                case MemberName.BackFrame:
                    writer.Write(m_backFrame);
                    break;

                case MemberName.ShadowIntensity:
                    writer.Write(m_shadowIntensity);
                    break;

                case MemberName.TextAntiAliasingQuality:
                    writer.Write(m_textAntiAliasingQuality);
                    break;

                case MemberName.TopImage:
                    writer.Write(m_topImage);
                    break;

                case MemberName.ColumnMembers:
                    writer.Write(m_columnMembers);
                    break;

                case MemberName.RowMembers:
                    writer.Write(m_rowMembers);
                    break;

                case MemberName.Rows:
                    writer.Write(m_rows);
                    break;

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

                case MemberName.Text:
                    writer.Write(m_text);
                    break;

                case MemberName.AllowUpsideDown:
                    writer.Write(m_allowUpsideDown);
                    break;

                case MemberName.DistanceFromScale:
                    writer.Write(m_distanceFromScale);
                    break;

                case MemberName.FontAngle:
                    writer.Write(m_fontAngle);
                    break;

                case MemberName.Placement:
                    writer.Write(m_placement);
                    break;

                case MemberName.RotateLabel:
                    writer.Write(m_rotateLabel);
                    break;

                case MemberName.TickMarkStyle:
                    writer.Write(m_tickMarkStyle);
                    break;

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

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

                case MemberName.UseFontPercent:
                    writer.Write(m_useFontPercent);
                    break;

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #21
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(ChartLegendColumn.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

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

                case MemberName.ColumnType:
                    writer.Write(this.m_columnType);
                    break;

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

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

                case MemberName.MinimumWidth:
                    writer.Write(this.m_minimumWidth);
                    break;

                case MemberName.MaximumWidth:
                    writer.Write(this.m_maximumWidth);
                    break;

                case MemberName.SeriesSymbolWidth:
                    writer.Write(this.m_seriesSymbolWidth);
                    break;

                case MemberName.SeriesSymbolHeight:
                    writer.Write(this.m_seriesSymbolHeight);
                    break;

                case MemberName.Header:
                    writer.Write(this.m_header);
                    break;

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

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

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #22
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(DataSet.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.DataSetCore:
                    writer.Write(this.m_dataSetCore);
                    break;

                case MemberName.DataRegions:
                    writer.WriteListOfReferences(this.m_dataRegions);
                    break;

                case MemberName.Aggregates:
                    writer.Write(this.m_aggregates);
                    break;

                case MemberName.UsedOnlyInParameters:
                    writer.Write(this.m_usedOnlyInParameters);
                    break;

                case MemberName.PostSortAggregates:
                    writer.Write(this.m_postSortAggregates);
                    break;

                case MemberName.HasDetailUserSortFilter:
                    writer.Write(this.m_hasDetailUserSortFilter);
                    break;

                case MemberName.UserSortExpressions:
                    writer.Write(this.m_userSortExpressions);
                    break;

                case MemberName.HasSubReports:
                    writer.Write(this.m_hasSubReports);
                    break;

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

                case MemberName.DataSource:
                    writer.WriteReference(this.m_dataSource);
                    break;

                case MemberName.Lookups:
                    writer.Write(this.m_lookups);
                    break;

                case MemberName.LookupDestinations:
                    writer.Write(this.m_lookupDestinationInfos);
                    break;

                case MemberName.AllowIncrementalProcessing:
                    writer.Write(this.m_allowIncrementalProcessing);
                    break;

                case MemberName.DefaultRelationships:
                    writer.Write(this.m_defaultRelationships);
                    break;

                case MemberName.HasScopeWithCustomAggregates:
                    writer.Write(this.m_hasScopeWithCustomAggregates);
                    break;

                default:
                    Global.Tracer.Assert(false, string.Empty);
                    break;
                }
            }
        }
Beispiel #23
0
        void IPersistable.Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(DataSource.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

                case MemberName.Transaction:
                    writer.Write(this.m_transaction);
                    break;

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

                case MemberName.ConnectString:
                    writer.Write(this.m_connectString);
                    break;

                case MemberName.IntegratedSecurity:
                    writer.Write(this.m_integratedSecurity);
                    break;

                case MemberName.Prompt:
                    writer.Write(this.m_prompt);
                    break;

                case MemberName.DataSourceReference:
                    writer.Write(this.m_dataSourceReference);
                    break;

                case MemberName.DataSets:
                    writer.Write(this.m_dataSets);
                    break;

                case MemberName.ID:
                    writer.Write(this.m_ID);
                    break;

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

                case MemberName.SharedDataSourceReferencePath:
                    writer.Write(this.m_sharedDataSourceReferencePath);
                    break;

                case MemberName.ReferenceID:
                    writer.Write(this.m_referenceID);
                    break;

                case MemberName.IsArtificialDataSource:
                    writer.Write(this.m_isArtificialDataSource);
                    break;

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

                case MemberName.CommandText:
                    writer.Write(m_commandText);
                    break;

                case MemberName.RewrittenCommandText:
                    writer.Write(m_rewrittenCommandText);
                    break;

                case MemberName.Fields:
                    writer.Write(m_fieldInfos);
                    break;

                case MemberName.CaseSensitivity:
                    writer.WriteEnum((int)m_caseSensitivity);
                    break;

                case MemberName.AccentSensitivity:
                    writer.WriteEnum((int)m_accentSensitivity);
                    break;

                case MemberName.KanatypeSensitivity:
                    writer.WriteEnum((int)m_kanatypeSensitivity);
                    break;

                case MemberName.WidthSensitivity:
                    writer.WriteEnum((int)m_widthSensitivity);
                    break;

                case MemberName.LCID:
                    writer.Write(m_lcid);
                    break;

                case MemberName.DataChunkName:
                    writer.Write(m_dataChunkName);
                    break;

                case MemberName.LookupResults:
                    writer.Write(m_lookupResults);
                    break;

                case MemberName.ExecutionTime:
                    writer.Write(m_executionTime);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #25
0
        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.Name:
                    writer.Write(m_name);
                    break;

                case MemberName.DistanceFromScale:
                    writer.Write(m_distanceFromScale);
                    break;

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

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

                case MemberName.StartWidth:
                    writer.Write(m_startWidth);
                    break;

                case MemberName.EndWidth:
                    writer.Write(m_endWidth);
                    break;

                case MemberName.InRangeBarPointerColor:
                    writer.Write(m_inRangeBarPointerColor);
                    break;

                case MemberName.InRangeLabelColor:
                    writer.Write(m_inRangeLabelColor);
                    break;

                case MemberName.InRangeTickMarksColor:
                    writer.Write(m_inRangeTickMarksColor);
                    break;

                case MemberName.BackgroundGradientType:
                    writer.Write(m_backgroundGradientType);
                    break;

                case MemberName.Placement:
                    writer.Write(m_placement);
                    break;

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

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

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

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #26
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.GaugeInputValue:
                    writer.Write(m_gaugeInputValue);
                    break;

                case MemberName.NumericIndicatorRanges:
                    writer.Write(m_numericIndicatorRanges);
                    break;

                case MemberName.DecimalDigitColor:
                    writer.Write(m_decimalDigitColor);
                    break;

                case MemberName.DigitColor:
                    writer.Write(m_digitColor);
                    break;

                case MemberName.UseFontPercent:
                    writer.Write(m_useFontPercent);
                    break;

                case MemberName.DecimalDigits:
                    writer.Write(m_decimalDigits);
                    break;

                case MemberName.Digits:
                    writer.Write(m_digits);
                    break;

                case MemberName.MinimumValue:
                    writer.Write(m_minimumValue);
                    break;

                case MemberName.MaximumValue:
                    writer.Write(m_maximumValue);
                    break;

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

                case MemberName.NonNumericString:
                    writer.Write(m_nonNumericString);
                    break;

                case MemberName.OutOfRangeString:
                    writer.Write(m_outOfRangeString);
                    break;

                case MemberName.ResizeMode:
                    writer.Write(m_resizeMode);
                    break;

                case MemberName.ShowDecimalPoint:
                    writer.Write(m_showDecimalPoint);
                    break;

                case MemberName.ShowLeadingZeros:
                    writer.Write(m_showLeadingZeros);
                    break;

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

                case MemberName.ShowSign:
                    writer.Write(m_showSign);
                    break;

                case MemberName.SnappingEnabled:
                    writer.Write(m_snappingEnabled);
                    break;

                case MemberName.SnappingInterval:
                    writer.Write(m_snappingInterval);
                    break;

                case MemberName.LedDimColor:
                    writer.Write(m_ledDimColor);
                    break;

                case MemberName.SeparatorWidth:
                    writer.Write(m_separatorWidth);
                    break;

                case MemberName.SeparatorColor:
                    writer.Write(m_separatorColor);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #27
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ChartSmartLabel.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.AllowOutSidePlotArea:
                    writer.Write(this.m_allowOutSidePlotArea);
                    break;

                case MemberName.CalloutBackColor:
                    writer.Write(this.m_calloutBackColor);
                    break;

                case MemberName.CalloutLineAnchor:
                    writer.Write(this.m_calloutLineAnchor);
                    break;

                case MemberName.CalloutLineColor:
                    writer.Write(this.m_calloutLineColor);
                    break;

                case MemberName.CalloutLineStyle:
                    writer.Write(this.m_calloutLineStyle);
                    break;

                case MemberName.CalloutLineWidth:
                    writer.Write(this.m_calloutLineWidth);
                    break;

                case MemberName.CalloutStyle:
                    writer.Write(this.m_calloutStyle);
                    break;

                case MemberName.ShowOverlapped:
                    writer.Write(this.m_showOverlapped);
                    break;

                case MemberName.MarkerOverlapping:
                    writer.Write(this.m_markerOverlapping);
                    break;

                case MemberName.MaxMovingDistance:
                    writer.Write(this.m_maxMovingDistance);
                    break;

                case MemberName.MinMovingDistance:
                    writer.Write(this.m_minMovingDistance);
                    break;

                case MemberName.NoMoveDirections:
                    writer.Write(this.m_noMoveDirections);
                    break;

                case MemberName.Disabled:
                    writer.Write(this.m_disabled);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #28
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.TextRuns:
                    writer.Write(m_textRuns);
                    break;

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

                case MemberName.LeftIndent:
                    writer.Write(m_leftIndent);
                    break;

                case MemberName.RightIndent:
                    writer.Write(m_rightIndent);
                    break;

                case MemberName.HangingIndent:
                    writer.Write(m_hangingIndent);
                    break;

                case MemberName.SpaceBefore:
                    writer.Write(m_spaceBefore);
                    break;

                case MemberName.SpaceAfter:
                    writer.Write(m_spaceAfter);
                    break;

                case MemberName.ListStyle:
                    writer.Write(m_listStyle);
                    break;

                case MemberName.ListLevel:
                    writer.Write(m_listLevel);
                    break;

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

                case MemberName.TextBox:
                    writer.WriteReference(m_textBox);
                    break;

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

                case MemberName.TextRunValueReferenced:
                    writer.Write(m_textRunValueReferenced);
                    break;

                default:
                    Global.Tracer.Assert(condition: 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.Name:
                    writer.Write(m_name);
                    break;

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

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

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

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

                case MemberName.ZIndex:
                    writer.Write(m_zIndex);
                    break;

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

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

                case MemberName.ParentItem:
                    writer.Write(m_parentItem);
                    break;

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

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

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

                case MemberName.TransformationType:
                    writer.Write(this.m_transformationType);
                    break;

                case MemberName.TransformationScope:
                    writer.Write(this.m_transformationScope);
                    break;

                case MemberName.MaximumValue:
                    writer.Write(this.m_maximumValue);
                    break;

                case MemberName.MinimumValue:
                    writer.Write(this.m_minimumValue);
                    break;

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

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

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

                case MemberName.IndicatorStates:
                    writer.Write(this.m_indicatorStates);
                    break;

                case MemberName.ResizeMode:
                    writer.Write(this.m_resizeMode);
                    break;

                case MemberName.Angle:
                    writer.Write(this.m_angle);
                    break;

                case MemberName.StateDataElementName:
                    writer.Write(this.m_stateDataElementName);
                    break;

                case MemberName.StateDataElementOutput:
                    writer.WriteEnum((int)this.m_stateDataElementOutput);
                    break;

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