internal override object PublishClone(AutomaticSubtotalContext context)
        {
            MapPolygonTemplate mapPolygonTemplate = (MapPolygonTemplate)base.PublishClone(context);

            if (m_scaleFactor != null)
            {
                mapPolygonTemplate.m_scaleFactor = (ExpressionInfo)m_scaleFactor.PublishClone(context);
            }
            if (m_centerPointOffsetX != null)
            {
                mapPolygonTemplate.m_centerPointOffsetX = (ExpressionInfo)m_centerPointOffsetX.PublishClone(context);
            }
            if (m_centerPointOffsetY != null)
            {
                mapPolygonTemplate.m_centerPointOffsetY = (ExpressionInfo)m_centerPointOffsetY.PublishClone(context);
            }
            if (m_showLabel != null)
            {
                mapPolygonTemplate.m_showLabel = (ExpressionInfo)m_showLabel.PublishClone(context);
            }
            if (m_labelPlacement != null)
            {
                mapPolygonTemplate.m_labelPlacement = (ExpressionInfo)m_labelPlacement.PublishClone(context);
            }
            return(mapPolygonTemplate);
        }
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            ChartDataLabel chartDataLabel = (ChartDataLabel)base.PublishClone(context);

            if (m_label != null)
            {
                chartDataLabel.m_label = (ExpressionInfo)m_label.PublishClone(context);
            }
            if (m_visible != null)
            {
                chartDataLabel.m_visible = (ExpressionInfo)m_visible.PublishClone(context);
            }
            if (m_position != null)
            {
                chartDataLabel.m_position = (ExpressionInfo)m_position.PublishClone(context);
            }
            if (m_rotation != null)
            {
                chartDataLabel.m_rotation = (ExpressionInfo)m_rotation.PublishClone(context);
            }
            if (m_useValueAsLabel != null)
            {
                chartDataLabel.m_useValueAsLabel = (ExpressionInfo)m_useValueAsLabel.PublishClone(context);
            }
            if (m_action != null)
            {
                chartDataLabel.m_action = (Action)m_action.PublishClone(context);
            }
            if (m_toolTip != null)
            {
                chartDataLabel.m_toolTip = (ExpressionInfo)m_toolTip.PublishClone(context);
            }
            return(chartDataLabel);
        }
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            PointerCap pointerCap = (PointerCap)base.PublishClone(context);

            if (m_capImage != null)
            {
                pointerCap.m_capImage = (CapImage)m_capImage.PublishClone(context);
            }
            if (m_onTop != null)
            {
                pointerCap.m_onTop = (ExpressionInfo)m_onTop.PublishClone(context);
            }
            if (m_reflection != null)
            {
                pointerCap.m_reflection = (ExpressionInfo)m_reflection.PublishClone(context);
            }
            if (m_capStyle != null)
            {
                pointerCap.m_capStyle = (ExpressionInfo)m_capStyle.PublishClone(context);
            }
            if (m_hidden != null)
            {
                pointerCap.m_hidden = (ExpressionInfo)m_hidden.PublishClone(context);
            }
            if (m_width != null)
            {
                pointerCap.m_width = (ExpressionInfo)m_width.PublishClone(context);
            }
            return(pointerCap);
        }
示例#4
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            MapDockableSubItem mapDockableSubItem = (MapDockableSubItem)base.PublishClone(context);

            if (m_action != null)
            {
                mapDockableSubItem.m_action = (Action)m_action.PublishClone(context);
            }
            if (m_position != null)
            {
                mapDockableSubItem.m_position = (ExpressionInfo)m_position.PublishClone(context);
            }
            if (m_dockOutsideViewport != null)
            {
                mapDockableSubItem.m_dockOutsideViewport = (ExpressionInfo)m_dockOutsideViewport.PublishClone(context);
            }
            if (m_hidden != null)
            {
                mapDockableSubItem.m_hidden = (ExpressionInfo)m_hidden.PublishClone(context);
            }
            if (m_toolTip != null)
            {
                mapDockableSubItem.m_toolTip = (ExpressionInfo)m_toolTip.PublishClone(context);
            }
            return(mapDockableSubItem);
        }
示例#5
0
        internal object PublishClone(AutomaticSubtotalContext context)
        {
            ChartDerivedSeries chartDerivedSeries = (ChartDerivedSeries)MemberwiseClone();

            chartDerivedSeries.m_chart = (Chart)context.CurrentDataRegionClone;
            if (m_series != null)
            {
                chartDerivedSeries.m_series = (ChartSeries)m_series.PublishClone(context);
            }
            if (m_sourceChartSeriesName != null)
            {
                chartDerivedSeries.m_sourceChartSeriesName = (ExpressionInfo)m_sourceChartSeriesName.PublishClone(context);
            }
            if (m_derivedSeriesFormula != null)
            {
                chartDerivedSeries.m_derivedSeriesFormula = (ExpressionInfo)m_derivedSeriesFormula.PublishClone(context);
            }
            if (m_chartFormulaParameters != null)
            {
                chartDerivedSeries.m_chartFormulaParameters = new List <ChartFormulaParameter>(m_chartFormulaParameters.Count);
                {
                    foreach (ChartFormulaParameter chartFormulaParameter in m_chartFormulaParameters)
                    {
                        chartDerivedSeries.m_chartFormulaParameters.Add((ChartFormulaParameter)chartFormulaParameter.PublishClone(context));
                    }
                    return(chartDerivedSeries);
                }
            }
            return(chartDerivedSeries);
        }
        internal object PublishClone(AutomaticSubtotalContext context, bool isSubtotalMember)
        {
            Visibility visibility = null;

            if (isSubtotalMember)
            {
                visibility          = new Visibility();
                visibility.m_hidden = ExpressionInfo.CreateConstExpression(value: true);
            }
            else
            {
                visibility = (Visibility)MemberwiseClone();
                if (m_hidden != null)
                {
                    visibility.m_hidden = (ExpressionInfo)m_hidden.PublishClone(context);
                }
                if (m_toggle != null)
                {
                    context.AddVisibilityWithToggleToUpdate(visibility);
                    visibility.m_toggle = (string)m_toggle.Clone();
                }
            }
            visibility.m_isClone = true;
            return(visibility);
        }
示例#7
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            TextRun textRun = (TextRun)base.PublishClone(context);

            if (m_value != null)
            {
                textRun.m_value = (ExpressionInfo)m_value.PublishClone(context);
            }
            if (m_toolTip != null)
            {
                textRun.m_toolTip = (ExpressionInfo)m_toolTip.PublishClone(context);
            }
            if (m_styleClass != null)
            {
                textRun.m_styleClass = (Style)m_styleClass.PublishClone(context);
            }
            if (m_markupType != null)
            {
                textRun.m_markupType = (ExpressionInfo)m_markupType.PublishClone(context);
            }
            if (m_action != null)
            {
                textRun.m_action = (Action)m_action.PublishClone(context);
            }
            return(textRun);
        }
        internal object PublishClone(AutomaticSubtotalContext context)
        {
            MapMarkerImage mapMarkerImage = (MapMarkerImage)MemberwiseClone();

            mapMarkerImage.m_map = context.CurrentMapClone;
            if (m_source != null)
            {
                mapMarkerImage.m_source = (ExpressionInfo)m_source.PublishClone(context);
            }
            if (m_value != null)
            {
                mapMarkerImage.m_value = (ExpressionInfo)m_value.PublishClone(context);
            }
            if (m_mIMEType != null)
            {
                mapMarkerImage.m_mIMEType = (ExpressionInfo)m_mIMEType.PublishClone(context);
            }
            if (m_transparentColor != null)
            {
                mapMarkerImage.m_transparentColor = (ExpressionInfo)m_transparentColor.PublishClone(context);
            }
            if (m_resizeMode != null)
            {
                mapMarkerImage.m_resizeMode = (ExpressionInfo)m_resizeMode.PublishClone(context);
            }
            return(mapMarkerImage);
        }
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            ChartAxisScaleBreak chartAxisScaleBreak = (ChartAxisScaleBreak)base.PublishClone(context);

            if (m_enabled != null)
            {
                chartAxisScaleBreak.m_enabled = (ExpressionInfo)m_enabled.PublishClone(context);
            }
            if (m_breakLineType != null)
            {
                chartAxisScaleBreak.m_breakLineType = (ExpressionInfo)m_breakLineType.PublishClone(context);
            }
            if (m_collapsibleSpaceThreshold != null)
            {
                chartAxisScaleBreak.m_collapsibleSpaceThreshold = (ExpressionInfo)m_collapsibleSpaceThreshold.PublishClone(context);
            }
            if (m_maxNumberOfBreaks != null)
            {
                chartAxisScaleBreak.m_maxNumberOfBreaks = (ExpressionInfo)m_maxNumberOfBreaks.PublishClone(context);
            }
            if (m_spacing != null)
            {
                chartAxisScaleBreak.m_spacing = (ExpressionInfo)m_spacing.PublishClone(context);
            }
            if (m_includeZero != null)
            {
                chartAxisScaleBreak.m_includeZero = (ExpressionInfo)m_includeZero.PublishClone(context);
            }
            return(chartAxisScaleBreak);
        }
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            MapTileLayer mapTileLayer = (MapTileLayer)base.PublishClone(context);

            if (m_serviceUrl != null)
            {
                mapTileLayer.m_serviceUrl = (ExpressionInfo)m_serviceUrl.PublishClone(context);
            }
            if (m_tileStyle != null)
            {
                mapTileLayer.m_tileStyle = (ExpressionInfo)m_tileStyle.PublishClone(context);
            }
            if (m_mapTiles != null)
            {
                mapTileLayer.m_mapTiles = new List <MapTile>(m_mapTiles.Count);
                foreach (MapTile mapTile in m_mapTiles)
                {
                    mapTileLayer.m_mapTiles.Add((MapTile)mapTile.PublishClone(context));
                }
            }
            if (m_useSecureConnection != null)
            {
                mapTileLayer.m_useSecureConnection = (ExpressionInfo)m_useSecureConnection.PublishClone(context);
            }
            return(mapTileLayer);
        }
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            ChartTickMarks chartTickMarks = (ChartTickMarks)base.PublishClone(context);

            if (m_enabled != null)
            {
                chartTickMarks.m_enabled = (ExpressionInfo)m_enabled.PublishClone(context);
            }
            if (m_type != null)
            {
                chartTickMarks.m_type = (ExpressionInfo)m_type.PublishClone(context);
            }
            if (m_length != null)
            {
                chartTickMarks.m_length = (ExpressionInfo)m_length.PublishClone(context);
            }
            if (m_interval != null)
            {
                chartTickMarks.m_interval = (ExpressionInfo)m_interval.PublishClone(context);
            }
            if (m_intervalType != null)
            {
                chartTickMarks.m_intervalType = (ExpressionInfo)m_intervalType.PublishClone(context);
            }
            if (m_intervalOffset != null)
            {
                chartTickMarks.m_intervalOffset = (ExpressionInfo)m_intervalOffset.PublishClone(context);
            }
            if (m_intervalOffsetType != null)
            {
                chartTickMarks.m_intervalOffsetType = (ExpressionInfo)m_intervalOffsetType.PublishClone(context);
            }
            return(chartTickMarks);
        }
示例#12
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            MapSubItem mapSubItem = (MapSubItem)base.PublishClone(context);

            if (m_mapLocation != null)
            {
                mapSubItem.m_mapLocation = (MapLocation)m_mapLocation.PublishClone(context);
            }
            if (m_mapSize != null)
            {
                mapSubItem.m_mapSize = (MapSize)m_mapSize.PublishClone(context);
            }
            if (m_leftMargin != null)
            {
                mapSubItem.m_leftMargin = (ExpressionInfo)m_leftMargin.PublishClone(context);
            }
            if (m_rightMargin != null)
            {
                mapSubItem.m_rightMargin = (ExpressionInfo)m_rightMargin.PublishClone(context);
            }
            if (m_topMargin != null)
            {
                mapSubItem.m_topMargin = (ExpressionInfo)m_topMargin.PublishClone(context);
            }
            if (m_bottomMargin != null)
            {
                mapSubItem.m_bottomMargin = (ExpressionInfo)m_bottomMargin.PublishClone(context);
            }
            if (m_zIndex != null)
            {
                mapSubItem.m_zIndex = (ExpressionInfo)m_zIndex.PublishClone(context);
            }
            return(mapSubItem);
        }
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            MapSpatialElementTemplate mapSpatialElementTemplate = (MapSpatialElementTemplate)base.PublishClone(context);

            mapSpatialElementTemplate.m_mapVectorLayer = context.CurrentMapVectorLayerClone;
            if (m_action != null)
            {
                mapSpatialElementTemplate.m_action = (Action)m_action.PublishClone(context);
            }
            if (m_hidden != null)
            {
                mapSpatialElementTemplate.m_hidden = (ExpressionInfo)m_hidden.PublishClone(context);
            }
            if (m_offsetX != null)
            {
                mapSpatialElementTemplate.m_offsetX = (ExpressionInfo)m_offsetX.PublishClone(context);
            }
            if (m_offsetY != null)
            {
                mapSpatialElementTemplate.m_offsetY = (ExpressionInfo)m_offsetY.PublishClone(context);
            }
            if (m_label != null)
            {
                mapSpatialElementTemplate.m_label = (ExpressionInfo)m_label.PublishClone(context);
            }
            if (m_toolTip != null)
            {
                mapSpatialElementTemplate.m_toolTip = (ExpressionInfo)m_toolTip.PublishClone(context);
            }
            if (m_dataElementLabel != null)
            {
                mapSpatialElementTemplate.m_dataElementLabel = (ExpressionInfo)m_dataElementLabel.PublishClone(context);
            }
            return(mapSpatialElementTemplate);
        }
示例#14
0
        internal object PublishClone(AutomaticSubtotalContext context)
        {
            MapLimits mapLimits = (MapLimits)MemberwiseClone();

            mapLimits.m_map = context.CurrentMapClone;
            if (m_minimumX != null)
            {
                mapLimits.m_minimumX = (ExpressionInfo)m_minimumX.PublishClone(context);
            }
            if (m_minimumY != null)
            {
                mapLimits.m_minimumY = (ExpressionInfo)m_minimumY.PublishClone(context);
            }
            if (m_maximumX != null)
            {
                mapLimits.m_maximumX = (ExpressionInfo)m_maximumX.PublishClone(context);
            }
            if (m_maximumY != null)
            {
                mapLimits.m_maximumY = (ExpressionInfo)m_maximumY.PublishClone(context);
            }
            if (m_limitToData != null)
            {
                mapLimits.m_limitToData = (ExpressionInfo)m_limitToData.PublishClone(context);
            }
            return(mapLimits);
        }
示例#15
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            BackFrame backFrame = (BackFrame)base.PublishClone(context);

            if (m_frameStyle != null)
            {
                backFrame.m_frameStyle = (ExpressionInfo)m_frameStyle.PublishClone(context);
            }
            if (m_frameShape != null)
            {
                backFrame.m_frameShape = (ExpressionInfo)m_frameShape.PublishClone(context);
            }
            if (m_frameWidth != null)
            {
                backFrame.m_frameWidth = (ExpressionInfo)m_frameWidth.PublishClone(context);
            }
            if (m_glassEffect != null)
            {
                backFrame.m_glassEffect = (ExpressionInfo)m_glassEffect.PublishClone(context);
            }
            if (m_frameBackground != null)
            {
                backFrame.m_frameBackground = (FrameBackground)m_frameBackground.PublishClone(context);
            }
            if (m_frameImage != null)
            {
                backFrame.m_frameImage = (FrameImage)m_frameImage.PublishClone(context);
            }
            return(backFrame);
        }
示例#16
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            PinLabel pinLabel = (PinLabel)base.PublishClone(context);

            if (m_text != null)
            {
                pinLabel.m_text = (ExpressionInfo)m_text.PublishClone(context);
            }
            if (m_allowUpsideDown != null)
            {
                pinLabel.m_allowUpsideDown = (ExpressionInfo)m_allowUpsideDown.PublishClone(context);
            }
            if (m_distanceFromScale != null)
            {
                pinLabel.m_distanceFromScale = (ExpressionInfo)m_distanceFromScale.PublishClone(context);
            }
            if (m_fontAngle != null)
            {
                pinLabel.m_fontAngle = (ExpressionInfo)m_fontAngle.PublishClone(context);
            }
            if (m_placement != null)
            {
                pinLabel.m_placement = (ExpressionInfo)m_placement.PublishClone(context);
            }
            if (m_rotateLabel != null)
            {
                pinLabel.m_rotateLabel = (ExpressionInfo)m_rotateLabel.PublishClone(context);
            }
            if (m_useFontPercent != null)
            {
                pinLabel.m_useFontPercent = (ExpressionInfo)m_useFontPercent.PublishClone(context);
            }
            return(pinLabel);
        }
示例#17
0
        internal object PublishClone(AutomaticSubtotalContext context)
        {
            IndicatorState indicatorState = (IndicatorState)MemberwiseClone();

            indicatorState.m_gaugePanel = (GaugePanel)context.CurrentDataRegionClone;
            if (m_startValue != null)
            {
                indicatorState.m_startValue = (GaugeInputValue)m_startValue.PublishClone(context);
            }
            if (m_endValue != null)
            {
                indicatorState.m_endValue = (GaugeInputValue)m_endValue.PublishClone(context);
            }
            if (m_color != null)
            {
                indicatorState.m_color = (ExpressionInfo)m_color.PublishClone(context);
            }
            if (m_scaleFactor != null)
            {
                indicatorState.m_scaleFactor = (ExpressionInfo)m_scaleFactor.PublishClone(context);
            }
            if (m_indicatorStyle != null)
            {
                indicatorState.m_indicatorStyle = (ExpressionInfo)m_indicatorStyle.PublishClone(context);
            }
            if (m_indicatorImage != null)
            {
                indicatorState.m_indicatorImage = (IndicatorImage)m_indicatorImage.PublishClone(context);
            }
            return(indicatorState);
        }
示例#18
0
        public object PublishClone(AutomaticSubtotalContext context)
        {
            ActionItem actionItem = (ActionItem)MemberwiseClone();

            if (m_hyperLinkURL != null)
            {
                actionItem.m_hyperLinkURL = (ExpressionInfo)m_hyperLinkURL.PublishClone(context);
            }
            if (m_drillthroughReportName != null)
            {
                actionItem.m_drillthroughReportName = (ExpressionInfo)m_drillthroughReportName.PublishClone(context);
            }
            if (m_drillthroughParameters != null)
            {
                actionItem.m_drillthroughParameters = new List <ParameterValue>(m_drillthroughParameters.Count);
                foreach (ParameterValue drillthroughParameter in m_drillthroughParameters)
                {
                    actionItem.m_drillthroughParameters.Add((ParameterValue)drillthroughParameter.PublishClone(context));
                }
            }
            if (m_drillthroughBookmarkLink != null)
            {
                actionItem.m_drillthroughBookmarkLink = (ExpressionInfo)m_drillthroughBookmarkLink.PublishClone(context);
            }
            if (m_bookmarkLink != null)
            {
                actionItem.m_bookmarkLink = (ExpressionInfo)m_bookmarkLink.PublishClone(context);
            }
            if (m_label != null)
            {
                actionItem.m_label = (ExpressionInfo)m_label.PublishClone(context);
            }
            return(actionItem);
        }
        internal object PublishClone(AutomaticSubtotalContext context)
        {
            GaugeInputValue gaugeInputValue = (GaugeInputValue)MemberwiseClone();

            gaugeInputValue.m_gaugePanel = (GaugePanel)context.CurrentDataRegionClone;
            if (m_value != null)
            {
                gaugeInputValue.m_value = (ExpressionInfo)m_value.PublishClone(context);
            }
            if (m_formula != null)
            {
                gaugeInputValue.m_formula = (ExpressionInfo)m_formula.PublishClone(context);
            }
            if (m_minPercent != null)
            {
                gaugeInputValue.m_minPercent = (ExpressionInfo)m_minPercent.PublishClone(context);
            }
            if (m_maxPercent != null)
            {
                gaugeInputValue.m_maxPercent = (ExpressionInfo)m_maxPercent.PublishClone(context);
            }
            if (m_multiplier != null)
            {
                gaugeInputValue.m_multiplier = (ExpressionInfo)m_multiplier.PublishClone(context);
            }
            if (m_addConstant != null)
            {
                gaugeInputValue.m_addConstant = (ExpressionInfo)m_addConstant.PublishClone(context);
            }
            return(gaugeInputValue);
        }
示例#20
0
        internal object PublishClone(AutomaticSubtotalContext context)
        {
            ChartSmartLabel chartSmartLabel = (ChartSmartLabel)MemberwiseClone();

            chartSmartLabel.m_chart = (Chart)context.CurrentDataRegionClone;
            if (m_allowOutSidePlotArea != null)
            {
                chartSmartLabel.m_allowOutSidePlotArea = (ExpressionInfo)m_allowOutSidePlotArea.PublishClone(context);
            }
            if (m_calloutBackColor != null)
            {
                chartSmartLabel.m_calloutBackColor = (ExpressionInfo)m_calloutBackColor.PublishClone(context);
            }
            if (m_calloutLineAnchor != null)
            {
                chartSmartLabel.m_calloutLineAnchor = (ExpressionInfo)m_calloutLineAnchor.PublishClone(context);
            }
            if (m_calloutLineColor != null)
            {
                chartSmartLabel.m_calloutLineColor = (ExpressionInfo)m_calloutLineColor.PublishClone(context);
            }
            if (m_calloutLineStyle != null)
            {
                chartSmartLabel.m_calloutLineStyle = (ExpressionInfo)m_calloutLineStyle.PublishClone(context);
            }
            if (m_calloutLineWidth != null)
            {
                chartSmartLabel.m_calloutLineWidth = (ExpressionInfo)m_calloutLineWidth.PublishClone(context);
            }
            if (m_calloutStyle != null)
            {
                chartSmartLabel.m_calloutStyle = (ExpressionInfo)m_calloutStyle.PublishClone(context);
            }
            if (m_showOverlapped != null)
            {
                chartSmartLabel.m_showOverlapped = (ExpressionInfo)m_showOverlapped.PublishClone(context);
            }
            if (m_markerOverlapping != null)
            {
                chartSmartLabel.m_markerOverlapping = (ExpressionInfo)m_markerOverlapping.PublishClone(context);
            }
            if (m_maxMovingDistance != null)
            {
                chartSmartLabel.m_maxMovingDistance = (ExpressionInfo)m_maxMovingDistance.PublishClone(context);
            }
            if (m_minMovingDistance != null)
            {
                chartSmartLabel.m_minMovingDistance = (ExpressionInfo)m_minMovingDistance.PublishClone(context);
            }
            if (m_noMoveDirections != null)
            {
                chartSmartLabel.m_noMoveDirections = (ChartNoMoveDirections)m_noMoveDirections.PublishClone(context);
            }
            if (m_disabled != null)
            {
                chartSmartLabel.m_disabled = (ExpressionInfo)m_disabled.PublishClone(context);
            }
            return(chartSmartLabel);
        }
示例#21
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            GaugePointer gaugePointer = (GaugePointer)base.PublishClone(context);

            if (m_action != null)
            {
                gaugePointer.m_action = (Action)m_action.PublishClone(context);
            }
            if (m_gaugeInputValue != null)
            {
                gaugePointer.m_gaugeInputValue = (GaugeInputValue)m_gaugeInputValue.PublishClone(context);
            }
            if (m_barStart != null)
            {
                gaugePointer.m_barStart = (ExpressionInfo)m_barStart.PublishClone(context);
            }
            if (m_distanceFromScale != null)
            {
                gaugePointer.m_distanceFromScale = (ExpressionInfo)m_distanceFromScale.PublishClone(context);
            }
            if (m_pointerImage != null)
            {
                gaugePointer.m_pointerImage = (PointerImage)m_pointerImage.PublishClone(context);
            }
            if (m_markerLength != null)
            {
                gaugePointer.m_markerLength = (ExpressionInfo)m_markerLength.PublishClone(context);
            }
            if (m_markerStyle != null)
            {
                gaugePointer.m_markerStyle = (ExpressionInfo)m_markerStyle.PublishClone(context);
            }
            if (m_placement != null)
            {
                gaugePointer.m_placement = (ExpressionInfo)m_placement.PublishClone(context);
            }
            if (m_snappingEnabled != null)
            {
                gaugePointer.m_snappingEnabled = (ExpressionInfo)m_snappingEnabled.PublishClone(context);
            }
            if (m_snappingInterval != null)
            {
                gaugePointer.m_snappingInterval = (ExpressionInfo)m_snappingInterval.PublishClone(context);
            }
            if (m_toolTip != null)
            {
                gaugePointer.m_toolTip = (ExpressionInfo)m_toolTip.PublishClone(context);
            }
            if (m_hidden != null)
            {
                gaugePointer.m_hidden = (ExpressionInfo)m_hidden.PublishClone(context);
            }
            if (m_width != null)
            {
                gaugePointer.m_width = (ExpressionInfo)m_width.PublishClone(context);
            }
            return(gaugePointer);
        }
示例#22
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            MapViewport mapViewport = (MapViewport)base.PublishClone(context);

            if (m_mapCoordinateSystem != null)
            {
                mapViewport.m_mapCoordinateSystem = (ExpressionInfo)m_mapCoordinateSystem.PublishClone(context);
            }
            if (m_mapProjection != null)
            {
                mapViewport.m_mapProjection = (ExpressionInfo)m_mapProjection.PublishClone(context);
            }
            if (m_projectionCenterX != null)
            {
                mapViewport.m_projectionCenterX = (ExpressionInfo)m_projectionCenterX.PublishClone(context);
            }
            if (m_projectionCenterY != null)
            {
                mapViewport.m_projectionCenterY = (ExpressionInfo)m_projectionCenterY.PublishClone(context);
            }
            if (m_mapLimits != null)
            {
                mapViewport.m_mapLimits = (MapLimits)m_mapLimits.PublishClone(context);
            }
            if (m_mapView != null)
            {
                mapViewport.m_mapView = (MapView)m_mapView.PublishClone(context);
            }
            if (m_maximumZoom != null)
            {
                mapViewport.m_maximumZoom = (ExpressionInfo)m_maximumZoom.PublishClone(context);
            }
            if (m_minimumZoom != null)
            {
                mapViewport.m_minimumZoom = (ExpressionInfo)m_minimumZoom.PublishClone(context);
            }
            if (m_contentMargin != null)
            {
                mapViewport.m_contentMargin = (ExpressionInfo)m_contentMargin.PublishClone(context);
            }
            if (m_mapMeridians != null)
            {
                mapViewport.m_mapMeridians = (MapGridLines)m_mapMeridians.PublishClone(context);
            }
            if (m_mapParallels != null)
            {
                mapViewport.m_mapParallels = (MapGridLines)m_mapParallels.PublishClone(context);
            }
            if (m_gridUnderContent != null)
            {
                mapViewport.m_gridUnderContent = (ExpressionInfo)m_gridUnderContent.PublishClone(context);
            }
            if (m_simplificationResolution != null)
            {
                mapViewport.m_simplificationResolution = (ExpressionInfo)m_simplificationResolution.PublishClone(context);
            }
            return(mapViewport);
        }
示例#23
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            ScaleRange scaleRange = (ScaleRange)base.PublishClone(context);

            if (m_action != null)
            {
                scaleRange.m_action = (Action)m_action.PublishClone(context);
            }
            if (m_distanceFromScale != null)
            {
                scaleRange.m_distanceFromScale = (ExpressionInfo)m_distanceFromScale.PublishClone(context);
            }
            if (m_startValue != null)
            {
                scaleRange.m_startValue = (GaugeInputValue)m_startValue.PublishClone(context);
            }
            if (m_endValue != null)
            {
                scaleRange.m_endValue = (GaugeInputValue)m_endValue.PublishClone(context);
            }
            if (m_startWidth != null)
            {
                scaleRange.m_startWidth = (ExpressionInfo)m_startWidth.PublishClone(context);
            }
            if (m_endWidth != null)
            {
                scaleRange.m_endWidth = (ExpressionInfo)m_endWidth.PublishClone(context);
            }
            if (m_inRangeBarPointerColor != null)
            {
                scaleRange.m_inRangeBarPointerColor = (ExpressionInfo)m_inRangeBarPointerColor.PublishClone(context);
            }
            if (m_inRangeLabelColor != null)
            {
                scaleRange.m_inRangeLabelColor = (ExpressionInfo)m_inRangeLabelColor.PublishClone(context);
            }
            if (m_inRangeTickMarksColor != null)
            {
                scaleRange.m_inRangeTickMarksColor = (ExpressionInfo)m_inRangeTickMarksColor.PublishClone(context);
            }
            if (m_backgroundGradientType != null)
            {
                scaleRange.m_backgroundGradientType = (ExpressionInfo)m_backgroundGradientType.PublishClone(context);
            }
            if (m_placement != null)
            {
                scaleRange.m_placement = (ExpressionInfo)m_placement.PublishClone(context);
            }
            if (m_toolTip != null)
            {
                scaleRange.m_toolTip = (ExpressionInfo)m_toolTip.PublishClone(context);
            }
            if (m_hidden != null)
            {
                scaleRange.m_hidden = (ExpressionInfo)m_hidden.PublishClone(context);
            }
            return(scaleRange);
        }
示例#24
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            ReportItem reportItem = (ReportItem)base.PublishClone(context);

            reportItem.m_name = context.CreateUniqueReportItemName(m_name, m_isClone);
            if (m_styleClass != null)
            {
                reportItem.m_styleClass = (Style)m_styleClass.PublishClone(context);
            }
            if (m_top != null)
            {
                reportItem.m_top = (string)m_top.Clone();
            }
            if (m_left != null)
            {
                reportItem.m_left = (string)m_left.Clone();
            }
            if (m_height != null)
            {
                reportItem.m_height = (string)m_height.Clone();
            }
            if (m_width != null)
            {
                reportItem.m_width = (string)m_width.Clone();
            }
            if (m_toolTip != null)
            {
                reportItem.m_toolTip = (ExpressionInfo)m_toolTip.PublishClone(context);
            }
            if (m_visibility != null)
            {
                reportItem.m_visibility = (Visibility)m_visibility.PublishClone(context, isSubtotalMember: false);
            }
            reportItem.m_documentMapLabel = null;
            reportItem.m_bookmark         = null;
            if (m_dataElementName != null)
            {
                reportItem.m_dataElementName = (string)m_dataElementName.Clone();
            }
            if (m_repeatWith != null)
            {
                context.AddReportItemWithRepeatWithToUpdate(reportItem);
                reportItem.m_repeatWith = (string)m_repeatWith.Clone();
            }
            if (m_customProperties != null)
            {
                reportItem.m_customProperties = new DataValueList(m_customProperties.Count);
                {
                    foreach (DataValue customProperty in m_customProperties)
                    {
                        reportItem.m_customProperties.Add((DataValue)customProperty.PublishClone(context));
                    }
                    return(reportItem);
                }
            }
            return(reportItem);
        }
		internal override object PublishClone(AutomaticSubtotalContext context)
		{
			ChartLegendTitle chartLegendTitle = (ChartLegendTitle)base.PublishClone(context);
			if (m_titleSeparator != null)
			{
				chartLegendTitle.m_titleSeparator = (ExpressionInfo)m_titleSeparator.PublishClone(context);
			}
			return chartLegendTitle;
		}
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            ChartTitleBase chartTitleBase = (ChartTitleBase)base.PublishClone(context);

            if (m_caption != null)
            {
                chartTitleBase.m_caption = (ExpressionInfo)m_caption.PublishClone(context);
            }
            return(chartTitleBase);
        }
示例#27
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            TopImage topImage = (TopImage)base.PublishClone(context);

            if (m_hueColor != null)
            {
                topImage.m_hueColor = (ExpressionInfo)m_hueColor.PublishClone(context);
            }
            return(topImage);
        }
示例#28
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            MapSpatialDataRegion mapSpatialDataRegion = (MapSpatialDataRegion)base.PublishClone(context);

            if (m_vectorData != null)
            {
                mapSpatialDataRegion.m_vectorData = (ExpressionInfo)m_vectorData.PublishClone(context);
            }
            return(mapSpatialDataRegion);
        }
示例#29
0
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            MapColorPaletteRule mapColorPaletteRule = (MapColorPaletteRule)base.PublishClone(context);

            if (m_palette != null)
            {
                mapColorPaletteRule.m_palette = (ExpressionInfo)m_palette.PublishClone(context);
            }
            return(mapColorPaletteRule);
        }
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            MapColorScaleTitle mapColorScaleTitle = (MapColorScaleTitle)base.PublishClone(context);

            if (m_caption != null)
            {
                mapColorScaleTitle.m_caption = (ExpressionInfo)m_caption.PublishClone(context);
            }
            return(mapColorScaleTitle);
        }