Esempio n. 1
0
 public LinearGauge this[string name]
 {
     get
     {
         for (int i = 0; i < Count; i++)
         {
             Microsoft.ReportingServices.ReportIntermediateFormat.LinearGauge linearGauge = m_gaugePanel.GaugePanelDef.LinearGauges[i];
             if (string.CompareOrdinal(name, linearGauge.Name) == 0)
             {
                 return(base[i]);
             }
         }
         throw new RenderingObjectModelException(ProcessingErrorCode.rsNotInCollection, name);
     }
 }
        internal override object PublishClone(AutomaticSubtotalContext context)
        {
            LinearGauge linearGauge = (LinearGauge)base.PublishClone(context);

            if (m_gaugeScales != null)
            {
                linearGauge.m_gaugeScales = new List <LinearScale>(m_gaugeScales.Count);
                foreach (LinearScale gaugeScale in m_gaugeScales)
                {
                    linearGauge.m_gaugeScales.Add((LinearScale)gaugeScale.PublishClone(context));
                }
            }
            if (m_orientation != null)
            {
                linearGauge.m_orientation = (ExpressionInfo)m_orientation.PublishClone(context);
            }
            return(linearGauge);
        }
Esempio n. 3
0
        internal override void DataRegionContentsSetExprHost(ObjectModelImpl reportObjectModel, bool traverseDataRegions)
        {
            if (m_exprHost == null)
            {
                return;
            }
            IList <LinearGaugeExprHost> linearGaugesHostsRemotable = m_exprHost.LinearGaugesHostsRemotable;

            if (m_linearGauges != null && linearGaugesHostsRemotable != null)
            {
                for (int i = 0; i < m_linearGauges.Count; i++)
                {
                    LinearGauge linearGauge = m_linearGauges[i];
                    if (linearGauge != null && linearGauge.ExpressionHostID > -1)
                    {
                        linearGauge.SetExprHost(linearGaugesHostsRemotable[linearGauge.ExpressionHostID], reportObjectModel);
                    }
                }
            }
            IList <RadialGaugeExprHost> radialGaugesHostsRemotable = m_exprHost.RadialGaugesHostsRemotable;

            if (m_radialGauges != null && radialGaugesHostsRemotable != null)
            {
                for (int j = 0; j < m_radialGauges.Count; j++)
                {
                    RadialGauge radialGauge = m_radialGauges[j];
                    if (radialGauge != null && radialGauge.ExpressionHostID > -1)
                    {
                        radialGauge.SetExprHost(radialGaugesHostsRemotable[radialGauge.ExpressionHostID], reportObjectModel);
                    }
                }
            }
            IList <NumericIndicatorExprHost> numericIndicatorsHostsRemotable = m_exprHost.NumericIndicatorsHostsRemotable;

            if (m_numericIndicators != null && numericIndicatorsHostsRemotable != null)
            {
                for (int k = 0; k < m_numericIndicators.Count; k++)
                {
                    NumericIndicator numericIndicator = m_numericIndicators[k];
                    if (numericIndicator != null && numericIndicator.ExpressionHostID > -1)
                    {
                        numericIndicator.SetExprHost(numericIndicatorsHostsRemotable[numericIndicator.ExpressionHostID], reportObjectModel);
                    }
                }
            }
            IList <StateIndicatorExprHost> stateIndicatorsHostsRemotable = m_exprHost.StateIndicatorsHostsRemotable;

            if (m_stateIndicators != null && stateIndicatorsHostsRemotable != null)
            {
                for (int l = 0; l < m_stateIndicators.Count; l++)
                {
                    StateIndicator stateIndicator = m_stateIndicators[l];
                    if (stateIndicator != null && stateIndicator.ExpressionHostID > -1)
                    {
                        stateIndicator.SetExprHost(stateIndicatorsHostsRemotable[stateIndicator.ExpressionHostID], reportObjectModel);
                    }
                }
            }
            IList <GaugeImageExprHost> gaugeImagesHostsRemotable = m_exprHost.GaugeImagesHostsRemotable;

            if (m_gaugeImages != null && gaugeImagesHostsRemotable != null)
            {
                for (int m = 0; m < m_gaugeImages.Count; m++)
                {
                    GaugeImage gaugeImage = m_gaugeImages[m];
                    if (gaugeImage != null && gaugeImage.ExpressionHostID > -1)
                    {
                        gaugeImage.SetExprHost(gaugeImagesHostsRemotable[gaugeImage.ExpressionHostID], reportObjectModel);
                    }
                }
            }
            IList <GaugeLabelExprHost> gaugeLabelsHostsRemotable = m_exprHost.GaugeLabelsHostsRemotable;

            if (m_gaugeLabels != null && gaugeLabelsHostsRemotable != null)
            {
                for (int n = 0; n < m_gaugeLabels.Count; n++)
                {
                    GaugeLabel gaugeLabel = m_gaugeLabels[n];
                    if (gaugeLabel != null && gaugeLabel.ExpressionHostID > -1)
                    {
                        gaugeLabel.SetExprHost(gaugeLabelsHostsRemotable[gaugeLabel.ExpressionHostID], reportObjectModel);
                    }
                }
            }
            if (m_backFrame != null && m_exprHost.BackFrameHost != null)
            {
                m_backFrame.SetExprHost(m_exprHost.BackFrameHost, reportObjectModel);
            }
            if (m_topImage != null && m_exprHost.TopImageHost != null)
            {
                m_topImage.SetExprHost(m_exprHost.TopImageHost, reportObjectModel);
            }
            IList <GaugeCellExprHost> cellHostsRemotable = m_exprHost.CellHostsRemotable;

            if (cellHostsRemotable != null && GaugeRow != null && cellHostsRemotable.Count > 0 && GaugeRow.GaugeCell != null)
            {
                GaugeRow.GaugeCell.SetExprHost(cellHostsRemotable[0], reportObjectModel);
            }
        }
Esempio n. 4
0
 internal LinearGauge(Microsoft.ReportingServices.ReportIntermediateFormat.LinearGauge defObject, GaugePanel gaugePanel)
     : base(defObject, gaugePanel)
 {
     m_defObject  = defObject;
     m_gaugePanel = gaugePanel;
 }