internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
        {
            if (m_textRuns == null)
            {
                m_textRuns = new List <RenderingTextRun>();
            }
            if (m_isSimple)
            {
                RPLTextBox       rplElement2      = rplElement as RPLTextBox;
                RenderingTextRun renderingTextRun = new RenderingTextRun();
                renderingTextRun.Initialize(rplElement2, bounds, m_textRuns.Count);
                renderingTextRun.ProcessRenderingElementContent(rplElement2, context, bounds);
                m_textRuns.Add(renderingTextRun);
                return;
            }
            RPLParagraph rPLParagraph = rplElement as RPLParagraph;

            for (RPLTextRun nextTextRun = rPLParagraph.GetNextTextRun(); nextTextRun != null; nextTextRun = rPLParagraph.GetNextTextRun())
            {
                RenderingTextRun renderingTextRun2 = new RenderingTextRun();
                renderingTextRun2.Initialize(nextTextRun, bounds, m_textRuns.Count);
                renderingTextRun2.ProcessRenderingElementContent(nextTextRun, context, bounds);
                m_textRuns.Add(renderingTextRun2);
            }
        }
Пример #2
0
        public override RPLElement CreateRPLElement(RPLElementProps props, PageContext pageContext)
        {
            RPLElement rPLElement = this.CreateRPLElement();

            base.WriteElementProps(rPLElement.ElementProps, pageContext);
            return(rPLElement);
        }
Пример #3
0
        public void RenderReportItem(RPLElement reportItem, RPLItemMeasurement measurement, StyleContext styleContext, ref int borderContext, bool renderId, bool treatAsTopLevel)
        {
            RPLElementProps    elementProps = reportItem.ElementProps;
            RPLElementPropsDef definition   = elementProps.Definition;

            this.RenderLine((RPLLine)reportItem, elementProps, (RPLLinePropsDef)definition, measurement, renderId, styleContext);
        }
Пример #4
0
        public void RenderReportItem(RPLElement reportItem, RPLItemMeasurement measurement, StyleContext styleContext, ref int borderContext, bool renderId, bool treatAsTopLevel)
        {
            RPLElementProps    elementProps = reportItem.ElementProps;
            RPLElementPropsDef definition   = elementProps.Definition;

            RenderRectangle((RPLContainer)reportItem, elementProps, definition, measurement, ref borderContext, renderId, styleContext, treatAsTopLevel);
        }
        internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
        {
            ImagePositionPX = new RectangleF(0f, 0f, context.GdiWriter.ConvertToPixels(base.Position.Width), context.GdiWriter.ConvertToPixels(base.Position.Height));
            RPLDynamicImageProps rPLDynamicImageProps = (RPLDynamicImageProps)InstanceProperties;
            Stream stream = rPLDynamicImageProps.DynamicImageContent;

            if (stream != null)
            {
                stream.Position = 0L;
            }
            else if (rPLDynamicImageProps.DynamicImageContentOffset >= 0)
            {
                byte[] image = context.RplReport.GetImage(rPLDynamicImageProps.DynamicImageContentOffset);
                if (image == null)
                {
                    return;
                }
                stream = new MemoryStream(image);
            }
            if (stream != null)
            {
                Image         = Image.FromStream(stream);
                ImagePosition = new RectangleF(base.Position.Location, base.Position.Size);
                GdiContext.CalculateUsableReportItemRectangle(InstanceProperties, ref ImagePosition);
                if (!(ImagePosition.Width <= 0f) && !(ImagePosition.Height <= 0f))
                {
                    ProcessImageMap(context);
                }
            }
        }
        internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
        {
            RPLTextBox         rPLTextBox         = rplElement as RPLTextBox;
            RPLTextBoxPropsDef rPLTextBoxPropsDef = DefinitionProperties as RPLTextBoxPropsDef;
            RPLTextBoxProps    rPLTextBoxProps    = InstanceProperties as RPLTextBoxProps;

            m_textPosition = new RectangleF(base.Position.X, base.Position.Y, base.Position.Width, base.Position.Height);
            GdiContext.CalculateUsableReportItemRectangle(InstanceProperties, ref m_textPosition);
            if (TextPosition.Width <= 0f || TextPosition.Height <= 0f)
            {
                return;
            }
            m_richTextBox = new TextBox(this);
            if (m_paragraphs == null)
            {
                m_paragraphs = new List <RenderingParagraph>();
            }
            if (rPLTextBoxPropsDef.IsSimple)
            {
                RenderingParagraph renderingParagraph = new RenderingParagraph();
                renderingParagraph.Initialize(rPLTextBox, TextPosition);
                renderingParagraph.ProcessRenderingElementContent(rPLTextBox, context, TextPosition);
                m_paragraphs.Add(renderingParagraph);
            }
            else
            {
                for (RPLParagraph nextParagraph = rPLTextBox.GetNextParagraph(); nextParagraph != null; nextParagraph = rPLTextBox.GetNextParagraph())
                {
                    RenderingParagraph renderingParagraph2 = new RenderingParagraph();
                    renderingParagraph2.Initialize(nextParagraph, TextPosition);
                    renderingParagraph2.ProcessRenderingElementContent(nextParagraph, context, TextPosition);
                    m_paragraphs.Add(renderingParagraph2);
                }
            }
            if (rPLTextBoxProps.IsToggleParent)
            {
                GetToggleImage(context.GdiWriter, out Bitmap _);
                m_textPosition.X     += m_toggleRectangleMM.Width + 2.2f;
                m_textPosition.Width -= m_toggleRectangleMM.Width + 2.2f;
                Action action = new ToggleAction(InstanceProperties.UniqueName, rPLTextBoxProps.Label, m_toggleRectangleMM, rPLTextBoxProps.ToggleState);
                RegisterAction(context, action);
            }
            if (rPLTextBoxPropsDef.CanSort)
            {
                GetSortImage(context.GdiWriter, out Bitmap _, out SortOrder nextOrder);
                m_textPosition.Width -= m_sortRectangleMM.Width + 2.2f;
                if (m_sortRectangleMM.Width > 0f)
                {
                    Action action2 = new SortAction(InstanceProperties.UniqueName, rPLTextBoxProps.Label, m_sortRectangleMM, nextOrder);
                    RegisterAction(context, action2);
                }
            }
            ProcessActions(context, InstanceProperties.UniqueName, ((RPLTextBoxProps)InstanceProperties).ActionInfo, TextPosition);
        }
Пример #7
0
        public void RenderReportItem(RPLElement reportItem, RPLItemMeasurement measurement, StyleContext styleContext, ref int borderContext, bool renderId, bool treatAsTopLevel)
        {
            RPLSubReport       rPLSubReport = (RPLSubReport)reportItem;
            RPLElementProps    elementProps = reportItem.ElementProps;
            RPLElementPropsDef definition   = elementProps.Definition;

            using (html5Renderer.m_reportContext.EnterSubreport(definition))
            {
                if (!styleContext.InTablix || renderId)
                {
                    styleContext.RenderMeasurements = false;
                    html5Renderer.WriteStream(HTMLElements.m_openDiv);
                    html5Renderer.RenderReportItemStyle(rPLSubReport, elementProps, definition, measurement, styleContext, ref borderContext, definition.ID);
                    if (renderId)
                    {
                        html5Renderer.RenderReportItemId(elementProps.UniqueName);
                    }
                    html5Renderer.WriteStreamCR(HTMLElements.m_closeBracket);
                }
                RPLItemMeasurement[] children = rPLSubReport.Children;
                int  num             = 0;
                int  num2            = borderContext;
                bool usePercentWidth = children.Length != 0;
                int  num3            = children.Length;
                for (int i = 0; i < num3; i++)
                {
                    if (i == 0 && num3 > 1 && (borderContext & 8) > 0)
                    {
                        num2 &= -9;
                    }
                    else if (i == 1 && (borderContext & 4) > 0)
                    {
                        num2 &= -5;
                    }
                    if (i > 0 && i == num3 - 1 && (borderContext & 8) > 0)
                    {
                        num2 |= 8;
                    }
                    num = num2;
                    RPLItemMeasurement rPLItemMeasurement = children[i];
                    RPLContainer       rPLContainer       = (RPLContainer)rPLItemMeasurement.Element;
                    RPLElementProps    elementProps2      = rPLContainer.ElementProps;
                    RPLElementPropsDef definition2        = elementProps2.Definition;
                    html5Renderer.m_isBody          = true;
                    html5Renderer.m_usePercentWidth = usePercentWidth;
                    new RectangleRenderer(html5Renderer).RenderReportItem(rPLContainer, rPLItemMeasurement, new StyleContext(), ref num, renderId: false, treatAsTopLevel);
                }
                if (!styleContext.InTablix || renderId)
                {
                    html5Renderer.WriteStreamCR(HTMLElements.m_closeDiv);
                }
            }
        }
Пример #8
0
        internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
        {
            Color = GdiContext.GetStylePropertyValueColor(InstanceProperties, 0);
            Width = GdiContext.GetStylePropertyValueSizeMM(InstanceProperties, 10);
            switch ((RPLFormat.BorderStyles)SharedRenderer.GetStylePropertyValueObject(InstanceProperties, 5))
            {
            case RPLFormat.BorderStyles.Dotted:
                Style = DashStyle.Dot;
                break;

            case RPLFormat.BorderStyles.Dashed:
                Style = DashStyle.Dash;
                break;

            default:
                Style = DashStyle.Solid;
                break;
            }
        }
Пример #9
0
 internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
 {
     Image = RenderingItem.GetImage(context, ((RPLImageProps)InstanceProperties).Image);
     if (Image == null)
     {
         Image  = GdiContext.ImageResources["InvalidImage"];
         Sizing = RPLFormat.Sizings.Clip;
     }
     else
     {
         Sizing = ((RPLImagePropsDef)DefinitionProperties).Sizing;
     }
     ImagePosition = new RectangleF(base.Position.Location, base.Position.Size);
     GdiContext.CalculateUsableReportItemRectangle(InstanceProperties, ref ImagePosition);
     if (!(ImagePosition.Width <= 0f))
     {
         _ = ImagePosition.Height;
         _ = 0f;
     }
 }
Пример #10
0
        internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
        {
            RPLContainer rPLContainer = (RPLContainer)rplElement;

            if (rPLContainer.Children == null)
            {
                return;
            }
            if (rPLContainer.Children.Length == 1)
            {
                RenderingItem renderingItem = RenderingItem.CreateRenderingItem(context, rPLContainer.Children[0], bounds);
                if (renderingItem != null)
                {
                    base.Children.Add(renderingItem);
                }
                rPLContainer.Children = null;
                return;
            }
            List <RPLItemMeasurement> list = new List <RPLItemMeasurement>(rPLContainer.Children.Length);

            for (int i = 0; i < rPLContainer.Children.Length; i++)
            {
                list.Add(rPLContainer.Children[i]);
            }
            rPLContainer.Children = null;
            RectangleF bounds2 = bounds;

            for (int j = 0; j < list.Count; j++)
            {
                RPLItemMeasurement rPLItemMeasurement = list[j];
                rPLItemMeasurement.Width = bounds.Width;
                bounds2.Height           = rPLItemMeasurement.Height;
                RenderingItem renderingItem2 = RenderingItem.CreateRenderingItem(context, rPLItemMeasurement, bounds2);
                if (renderingItem2 != null)
                {
                    base.Children.Add(renderingItem2);
                }
                bounds2.Y += rPLItemMeasurement.Height;
                list[j]    = null;
            }
        }
Пример #11
0
        internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
        {
            RPLContainer rPLContainer = (RPLContainer)rplElement;

            if (rPLContainer.Children == null)
            {
                return;
            }
            if (rPLContainer.Children.Length == 1)
            {
                RenderingItem renderingItem = RenderingItem.CreateRenderingItem(context, rPLContainer.Children[0], bounds);
                if (renderingItem != null)
                {
                    Children.Add(renderingItem);
                }
                rPLContainer.Children = null;
                return;
            }
            List <RPLItemMeasurement> list = new List <RPLItemMeasurement>(rPLContainer.Children.Length);

            for (int i = 0; i < rPLContainer.Children.Length; i++)
            {
                list.Add(rPLContainer.Children[i]);
            }
            rPLContainer.Children = null;
            list.Sort(new ZIndexComparer());
            for (int j = 0; j < list.Count; j++)
            {
                RenderingItem renderingItem2 = RenderingItem.CreateRenderingItem(context, list[j], bounds);
                if (renderingItem2 != null)
                {
                    Children.Add(renderingItem2);
                }
                list[j] = null;
            }
        }
        internal override void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
        {
            RPLTablix       rPLTablix        = (RPLTablix)rplElement;
            FixedHeaderItem fixedHeaderItem  = null;
            FixedHeaderItem fixedHeaderItem2 = null;
            FixedHeaderItem fixedHeaderItem3 = null;
            float           num  = 0f;
            float           num2 = bounds.Top;

            float[] array = null;
            array = ((rPLTablix.ColumnWidths == null) ? new float[0] : new float[rPLTablix.ColumnWidths.Length]);
            int[] array2 = new int[array.Length];
            for (int i = 0; i < array2.Length; i++)
            {
                array2[i] = int.MaxValue;
            }
            for (int j = 0; j < array.Length; j++)
            {
                if (j > 0)
                {
                    array[j] = array[j - 1] + rPLTablix.ColumnWidths[j - 1];
                }
                if (rPLTablix.FixedColumns[j])
                {
                    if (fixedHeaderItem3 == null)
                    {
                        fixedHeaderItem3              = new FixedHeaderItem(this, base.Position, FixedHeaderItem.LayoutType.Vertical);
                        fixedHeaderItem3.Bounds.X    += array[j];
                        fixedHeaderItem3.Bounds.Width = rPLTablix.ColumnWidths[j];
                    }
                    else
                    {
                        fixedHeaderItem3.Bounds.X      = Math.Min(fixedHeaderItem3.Bounds.X, base.Position.X + array[j]);
                        fixedHeaderItem3.Bounds.Width += rPLTablix.ColumnWidths[j];
                    }
                }
            }
            if (rPLTablix.FixedRow(0))
            {
                fixedHeaderItem = new FixedHeaderItem(this, base.Position, FixedHeaderItem.LayoutType.Horizontal);
                fixedHeaderItem.Bounds.Height = 0f;
                context.RenderingReport.FixedHeaders.Add(fixedHeaderItem);
            }
            if (fixedHeaderItem3 != null)
            {
                context.RenderingReport.FixedHeaders.Add(fixedHeaderItem3);
                if (rPLTablix.FixedRow(0))
                {
                    fixedHeaderItem2 = new FixedHeaderItem(this, base.Position, FixedHeaderItem.LayoutType.Corner);
                    context.RenderingReport.FixedHeaders.Add(fixedHeaderItem2);
                }
            }
            int          num3 = 0;
            int          num4 = -1;
            RPLTablixRow nextRow;

            while ((nextRow = rPLTablix.GetNextRow()) != null)
            {
                if (nextRow is RPLTablixOmittedRow)
                {
                    continue;
                }
                SharedRenderer.CalculateColumnZIndexes(rPLTablix, nextRow, num3, array2);
                if (nextRow.OmittedHeaders != null)
                {
                    for (int k = 0; k < nextRow.OmittedHeaders.Count; k++)
                    {
                        RPLTablixMemberCell rPLTablixMemberCell = nextRow.OmittedHeaders[k];
                        if (!string.IsNullOrEmpty(rPLTablixMemberCell.GroupLabel))
                        {
                            float x = bounds.X;
                            if (rPLTablixMemberCell.ColIndex < array.Length)
                            {
                                x = array[rPLTablixMemberCell.ColIndex];
                            }
                            context.RenderingReport.Labels.Add(rPLTablixMemberCell.UniqueName, new LabelPoint(x, num2));
                        }
                    }
                }
                int num5 = int.MaxValue;
                for (int l = 0; l < nextRow.NumCells; l++)
                {
                    RPLTablixCell      rPLTablixCell      = nextRow[l];
                    RPLItemMeasurement rPLItemMeasurement = new RPLItemMeasurement();
                    rPLItemMeasurement.Element = rPLTablixCell.Element;
                    rPLItemMeasurement.Left    = array[rPLTablixCell.ColIndex];
                    rPLItemMeasurement.Top     = num;
                    rPLItemMeasurement.Width   = rPLTablix.GetColumnWidth(rPLTablixCell.ColIndex, rPLTablixCell.ColSpan);
                    rPLItemMeasurement.Height  = rPLTablix.GetRowHeight(rPLTablixCell.RowIndex, rPLTablixCell.RowSpan);
                    RenderingItem renderingItem = RenderingItem.CreateRenderingItem(context, rPLItemMeasurement, bounds);
                    if (renderingItem == null)
                    {
                        continue;
                    }
                    if (renderingItem is RenderingDynamicImage)
                    {
                        ((RenderingDynamicImage)renderingItem).Sizing = RPLFormat.Sizings.Fit;
                    }
                    RPLTablixMemberCell rPLTablixMemberCell2 = rPLTablixCell as RPLTablixMemberCell;
                    if (rPLTablixMemberCell2 != null && !string.IsNullOrEmpty(rPLTablixMemberCell2.GroupLabel))
                    {
                        context.RenderingReport.Labels.Add(rPLTablixMemberCell2.UniqueName, new LabelPoint(rPLItemMeasurement.Left, rPLItemMeasurement.Top));
                    }
                    if (renderingItem.HasBorders)
                    {
                        renderingItem.DelayDrawBorders = true;
                        if (num3 < rPLTablix.ColumnHeaderRows && rPLTablixCell is RPLTablixCornerCell)
                        {
                            m_cornerBorders.Add(new RenderingItemBorderTablix(0, 0, rPLTablixCell.RowIndex, rPLTablixCell.ColIndex, renderingItem));
                        }
                        else
                        {
                            if (num5 == int.MaxValue)
                            {
                                num5 = SharedRenderer.CalculateRowZIndex(nextRow);
                            }
                            if (num5 == int.MaxValue)
                            {
                                num5 = num4;
                            }
                            RenderingItemBorderTablix renderingItemBorderTablix = new RenderingItemBorderTablix(num5, array2[rPLTablixCell.ColIndex], rPLTablixCell.RowIndex, rPLTablixCell.ColIndex, renderingItem);
                            if (rPLTablixMemberCell2 != null)
                            {
                                if (num3 < rPLTablix.ColumnHeaderRows)
                                {
                                    m_columnHeaderBorders.Add(renderingItemBorderTablix);
                                }
                                else
                                {
                                    renderingItemBorderTablix.CompareRowFirst = false;
                                    m_rowHeaderBorders.Add(renderingItemBorderTablix);
                                }
                            }
                            else
                            {
                                m_detailCellBorders.Add(renderingItemBorderTablix);
                            }
                        }
                    }
                    base.Children.Add(renderingItem);
                    fixedHeaderItem?.RenderingItems.Add(renderingItem);
                    if (rPLTablix.FixedColumns[rPLTablixCell.ColIndex])
                    {
                        fixedHeaderItem3.RenderingItems.Add(renderingItem);
                    }
                    if (fixedHeaderItem2 != null && rPLTablixCell is RPLTablixCornerCell)
                    {
                        fixedHeaderItem2.RenderingItems.Add(renderingItem);
                        fixedHeaderItem2.Bounds = renderingItem.Position;
                    }
                }
                num4 = num5;
                if (fixedHeaderItem != null)
                {
                    fixedHeaderItem.Bounds.Height += rPLTablix.RowHeights[num3];
                    if (num3 == rPLTablix.RowHeights.Length - 1 || !rPLTablix.FixedRow(num3 + 1))
                    {
                        fixedHeaderItem = null;
                    }
                }
                num  += rPLTablix.RowHeights[num3];
                num2 += rPLTablix.RowHeights[num3];
                num3++;
                for (int m = 0; m < nextRow.NumCells; m++)
                {
                    nextRow[m] = null;
                }
            }
            m_detailCellBorders.Sort(new ZIndexComparer());
            m_columnHeaderBorders.Sort(new ZIndexComparer());
            m_rowHeaderBorders.Sort(new ZIndexComparer());
            m_cornerBorders.Sort(new ZIndexComparer());
            RectangleF position = base.Position;

            if (array.Length != 0)
            {
                position.Width = array[array.Length - 1] + rPLTablix.ColumnWidths[rPLTablix.ColumnWidths.Length - 1];
            }
            position.Height = num;
        }
Пример #13
0
        public void RenderReportItem(RPLElement reportItem, RPLItemMeasurement measurement, StyleContext styleContext, ref int borderContext, bool renderId, bool treatAsTopLevel)
        {
            RPLImageProps    rPLImageProps    = (RPLImageProps)reportItem.ElementProps;
            RPLImagePropsDef rPLImagePropsDef = (RPLImagePropsDef)rPLImageProps.Definition;

            RPLFormat.Sizings sizing = rPLImagePropsDef.Sizing;
            RPLImageData      image  = rPLImageProps.Image;

            this.html5Renderer.GetInnerContainerHeightSubtractBorders(measurement, rPLImageProps.Style);
            float  innerContainerWidthSubtractBorders = this.html5Renderer.GetInnerContainerWidthSubtractBorders(measurement, rPLImageProps.Style);
            string text      = this.html5Renderer.GetImageUrl(true, image);
            string ariaLabel = null;
            string role      = null;
            string tooltip   = this.html5Renderer.GetTooltip(rPLImageProps);

            if (treatAsTopLevel)
            {
                ariaLabel = (string.IsNullOrEmpty(tooltip) ? RenderRes.AccessibleImageLabel : RenderRes.AccessibleImageNavigationGroupLabel(tooltip));
                role      = HTMLElements.m_navigationRole;
            }
            string altText = string.IsNullOrEmpty(tooltip) ? RenderRes.AccessibleImageLabel : tooltip;
            Dictionary <string, string> dictionary = new Dictionary <string, string>();

            if (this.html5Renderer.m_elementExtender.ShouldApplyToElement(treatAsTopLevel))
            {
                dictionary.Add(HTMLElements.m_reportItemDataName, this.html5Renderer.m_elementExtender.ApplyToElement());
                dictionary.Add(HTMLElements.m_reportItemCustomAttrStr, this.html5Renderer.GetReportItemPath(rPLImagePropsDef.Name));
            }
            bool flag = rPLImageProps.ActionImageMapAreas != null && rPLImageProps.ActionImageMapAreas.Length > 0;

            if (flag)
            {
                string s = HTMLElements.m_hashTag + this.html5Renderer.m_deviceInfo.HtmlPrefixId + HTMLElements.m_mapPrefixString + rPLImageProps.UniqueName;
                dictionary.Add(HTMLElements.m_useMapName, HttpUtility.HtmlAttributeEncode(s));
            }
            if (this.html5Renderer.HasAction(rPLImageProps.ActionInfo))
            {
                this.RenderElementHyperlink(rPLImageProps.Style, rPLImageProps.ActionInfo.Actions[0]);
            }
            if (!styleContext.InTablix)
            {
                if (sizing == RPLFormat.Sizings.AutoSize)
                {
                    styleContext.RenderMeasurements = false;
                }
                this.html5Renderer.WriteStream(HTMLElements.m_openDiv);
                this.html5Renderer.RenderReportItemStyle(reportItem, (RPLElementProps)rPLImageProps, (RPLElementPropsDef)rPLImagePropsDef, measurement, styleContext, ref borderContext, rPLImagePropsDef.ID);
                this.html5Renderer.WriteStream(HTMLElements.m_closeBracket);
            }
            if (string.IsNullOrEmpty(text))
            {
                text = "data:image/gif;base64," + Convert.ToBase64String(HTMLRendererResources.GetBytes("Blank.gif"));
            }
            HtmlElement htmlElement;

            switch (sizing)
            {
            case RPLFormat.Sizings.FitProportional:
                htmlElement = new FitProportionalImageElement(text, innerContainerWidthSubtractBorders, role, altText, ariaLabel, dictionary);
                break;

            case RPLFormat.Sizings.Fit:
                htmlElement = new FitImageElement(text, role, altText, ariaLabel, dictionary);
                break;

            case RPLFormat.Sizings.Clip:
                htmlElement = new ClipImageElement(text, role, altText, ariaLabel, dictionary);
                break;

            default:
                htmlElement = new OriginalSizeImageElement(text, role, altText, ariaLabel, dictionary);
                break;
            }
            htmlElement.Render(new Html5OutputStream(this.html5Renderer));
            if (!styleContext.InTablix)
            {
                this.html5Renderer.WriteStream(HTMLElements.m_closeDiv);
            }
            if (this.html5Renderer.HasAction(rPLImageProps.ActionInfo))
            {
                this.html5Renderer.WriteStream(HTMLElements.m_closeA);
            }
            if (flag)
            {
                this.html5Renderer.RenderImageMapAreas(rPLImageProps.ActionImageMapAreas, (double)measurement.Width, (double)measurement.Height, rPLImageProps.UniqueName, 0, 0);
            }
        }
Пример #14
0
        private void FillAndFindOverlap(RPLItemMeasurement[] repItemCollection, double delta)
        {
            bool               flag               = false;
            int                num                = -1;
            int                num2               = -1;
            int                colSpans           = 0;
            int                rowSpans           = 0;
            int                num3               = 0;
            PageTableCell      pageTableCell      = null;
            int                num4               = 0;
            RPLItemMeasurement rPLItemMeasurement = null;
            RPLElement         rPLElement         = null;

            while (num4 < repItemCollection.Length)
            {
                num  = -1;
                num2 = -1;
                flag = false;
                rPLItemMeasurement = repItemCollection[num4];
                if (SkipReportItem(rPLItemMeasurement))
                {
                    num4++;
                    continue;
                }
                rPLElement = rPLItemMeasurement.Element;
                flag       = FindRItemCell(rPLItemMeasurement, ref num, ref num2, delta);
                if (!flag && !(rPLElement is RPLLine))
                {
                    num4++;
                    continue;
                }
                RPLLine rPLLine = rPLElement as RPLLine;
                if (rPLLine != null)
                {
                    RPLLinePropsDef rPLLinePropsDef = rPLLine.ElementPropsDef as RPLLinePropsDef;
                    float           width           = rPLItemMeasurement.Width;
                    if ((width >= 0f && width < 0.01f) || (width < 0f && width > -0.01f))
                    {
                        if (!flag)
                        {
                            int  num5  = 0;
                            bool flag2 = true;
                            while (flag2 && num5 < m_nrRows)
                            {
                                if (m_tableGrid[num5 * m_nrCols].YValue == (float)((double)rPLItemMeasurement.Top - delta))
                                {
                                    num2  = num5;
                                    flag2 = false;
                                }
                                num5++;
                            }
                            num = m_nrCols - 1;
                            if (!flag2)
                            {
                                AttachVerticalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, leftBorder: false);
                            }
                        }
                        else
                        {
                            AttachVerticalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, leftBorder: true);
                        }
                        num4++;
                        continue;
                    }
                    width = rPLItemMeasurement.Height;
                    if ((width >= 0f && width < 0.01f) || (width < 0f && width > -0.01f))
                    {
                        if (!flag)
                        {
                            int  num6  = 0;
                            bool flag3 = true;
                            while (flag3 && num6 < m_nrCols)
                            {
                                if (m_tableGrid[num6].XValue == rPLItemMeasurement.Left)
                                {
                                    num   = num6;
                                    flag3 = false;
                                }
                                num6++;
                            }
                            num2 = m_nrRows - 1;
                            AttachHorizontalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, topBorder: false);
                        }
                        else
                        {
                            AttachHorizontalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, topBorder: true);
                        }
                        num4++;
                        continue;
                    }
                }
                num3          = num + m_nrCols * num2;
                pageTableCell = m_tableGrid[num3];
                if ((pageTableCell.InUse || pageTableCell.Eaten) && rPLElement is RPLLine && rPLItemMeasurement.Width != 0f && rPLItemMeasurement.Height != 0f)
                {
                    num4++;
                    continue;
                }
                ComputeColRowSpan(rPLItemMeasurement, num, num2, ref colSpans, ref rowSpans);
                AttachRItem(num, num2, colSpans, rowSpans, rPLItemMeasurement);
                num4++;
            }
        }
Пример #15
0
		internal override RPLElement CreateRPLElement(RPLElementProps props, PageContext pageContext)
		{
			RPLElement rPLElement = CreateRPLElement();
			WriteElementProps(rPLElement.ElementProps, pageContext);
			return rPLElement;
		}
 protected override void RenderRPLContainer(RPLElement element, bool inTablix, RPLItemMeasurement measurement, int cellIndex, BorderContext borderContext, bool hasBorder)
 {
     RenderRPLContainerProperties(element, inTablix, cellIndex);
     RenderRPLContainerContents(element, measurement, borderContext, inTablix, hasBorder);
 }
        private void FillAndFindOverlap(RPLItemMeasurement[] repItemCollection, double delta)
        {
            bool               flag               = false;
            int                num                = -1;
            int                num2               = -1;
            int                colSpan            = 0;
            int                rowSpan            = 0;
            int                num3               = 0;
            PageTableCell      pageTableCell      = null;
            int                num4               = 0;
            RPLItemMeasurement rPLItemMeasurement = null;
            RPLElement         rPLElement         = null;

            while (num4 < repItemCollection.Length)
            {
                num  = -1;
                num2 = -1;
                flag = false;
                rPLItemMeasurement = repItemCollection[num4];
                if (PageTableLayout.SkipReportItem(rPLItemMeasurement))
                {
                    num4++;
                }
                else
                {
                    rPLElement = rPLItemMeasurement.Element;
                    flag       = this.FindRItemCell(rPLItemMeasurement, ref num, ref num2, delta);
                    if (!flag && !(rPLElement is RPLLine))
                    {
                        num4++;
                    }
                    else
                    {
                        RPLLine rPLLine = rPLElement as RPLLine;
                        if (rPLLine != null)
                        {
                            RPLElementPropsDef elementPropsDef = rPLLine.ElementPropsDef;
                            float width = rPLItemMeasurement.Width;
                            if (width >= 0.0 && width < 0.0099999997764825821)
                            {
                                goto IL_00b8;
                            }
                            if (width < 0.0 && width > -0.0099999997764825821)
                            {
                                goto IL_00b8;
                            }
                            width = rPLItemMeasurement.Height;
                            if (width >= 0.0 && width < 0.0099999997764825821)
                            {
                                goto IL_0176;
                            }
                            if (width < 0.0 && width > -0.0099999997764825821)
                            {
                                goto IL_0176;
                            }
                        }
                        num3          = num + this.m_nrCols * num2;
                        pageTableCell = this.m_tableGrid[num3];
                        if ((pageTableCell.InUse || pageTableCell.Eaten) && rPLElement is RPLLine && rPLItemMeasurement.Width != 0.0 && rPLItemMeasurement.Height != 0.0)
                        {
                            num4++;
                            continue;
                        }
                        this.ComputeColRowSpan(rPLItemMeasurement, num, num2, ref colSpan, ref rowSpan);
                        this.AttachRItem(num, num2, colSpan, rowSpan, rPLItemMeasurement);
                        num4++;
                    }
                }
                continue;
IL_00b8:
                if (!flag)
                {
                    int  num5  = 0;
                    bool flag2 = true;
                    while (flag2 && num5 < this.m_nrRows)
                    {
                        if (this.m_tableGrid[num5 * this.m_nrCols].YValue == (float)((double)rPLItemMeasurement.Top - delta))
                        {
                            num2  = num5;
                            flag2 = false;
                        }
                        num5++;
                    }
                    num = this.m_nrCols - 1;
                    if (!flag2)
                    {
                        this.AttachVerticalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, false);
                    }
                }
                else
                {
                    this.AttachVerticalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, true);
                }
                num4++;
                continue;
IL_0176:
                if (!flag)
                {
                    int  num6  = 0;
                    bool flag3 = true;
                    while (flag3 && num6 < this.m_nrCols)
                    {
                        if (this.m_tableGrid[num6].XValue == rPLItemMeasurement.Left)
                        {
                            num   = num6;
                            flag3 = false;
                        }
                        num6++;
                    }
                    num2 = this.m_nrRows - 1;
                    this.AttachHorizontalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, false);
                }
                else
                {
                    this.AttachHorizontalBorder(num, num2, rPLItemMeasurement, (RPLLine)rPLElement, true);
                }
                num4++;
            }
        }
 internal void Initialize(RPLElement rplElement, RectangleF bounds, int indexInParagraph)
 {
     Initialize(rplElement);
     m_indexInParagraph = indexInParagraph;
     m_position         = GdiContext.GetMeasurementRectangle(null, bounds);
 }
Пример #19
0
 public virtual object PreProcessReportItem(RPLElement element, RPLElementProps instanceProperties, RectangleF position, bool hasLabel)
 {
     return(null);
 }
Пример #20
0
 protected virtual void Initialize(RPLElement rplElement)
 {
     m_instanceProperties   = rplElement.ElementProps;
     m_definitionProperties = m_instanceProperties.Definition;
 }
Пример #21
0
        private static void ReadMeasurement(RPLElement element, ALayout layout, int top, int left, int generationIndex, BlockOutlines blockOutlines, Dictionary <string, ToggleParent> toggleParents, bool suppressOutlines, int elementWidth, string subreportLanguage)
        {
            RPLContainer rPLContainer = element as RPLContainer;

            if (rPLContainer != null)
            {
                if (rPLContainer.Children != null)
                {
                    bool         flag         = false;
                    int          num          = 0;
                    RPLSubReport rPLSubReport = element as RPLSubReport;
                    if (rPLSubReport != null)
                    {
                        flag = true;
                        if (!suppressOutlines)
                        {
                            toggleParents = new Dictionary <string, ToggleParent>();
                        }
                        string language = ((RPLSubReportProps)rPLSubReport.ElementProps).Language;
                        if (!string.IsNullOrEmpty(language))
                        {
                            subreportLanguage = language;
                        }
                    }
                    int[]     array  = new int[rPLContainer.Children.Length];
                    int[]     array2 = new int[rPLContainer.Children.Length];
                    int[]     array3 = new int[rPLContainer.Children.Length];
                    RPLItem[] array4 = new RPLItem[rPLContainer.Children.Length];
                    for (int i = 0; i < rPLContainer.Children.Length; i++)
                    {
                        RPLItemMeasurement rPLItemMeasurement = rPLContainer.Children[i];
                        if (0.0 == rPLItemMeasurement.Width && 0.0 == rPLItemMeasurement.Height)
                        {
                            rPLContainer.Children[i] = null;
                        }
                        else
                        {
                            if ((0.0 == rPLItemMeasurement.Width || 0.0 == rPLItemMeasurement.Height) && !(rPLItemMeasurement.Element is RPLLine))
                            {
                                rPLContainer.Children[i] = null;
                                continue;
                            }
                            int num2 = LayoutConvert.ConvertMMTo20thPoints((double)rPLItemMeasurement.Height);
                            int num3 = 0;
                            if (flag)
                            {
                                num3      = elementWidth;
                                array2[i] = LayoutConvert.ConvertMMTo20thPoints((double)rPLItemMeasurement.Top) + top + num;
                                num      += num2;
                            }
                            else
                            {
                                num3      = LayoutConvert.ConvertMMTo20thPoints((double)rPLItemMeasurement.Width);
                                array2[i] = LayoutConvert.ConvertMMTo20thPoints((double)rPLItemMeasurement.Top) + top;
                            }
                            array[i]  = num3;
                            array3[i] = LayoutConvert.ConvertMMTo20thPoints((double)rPLItemMeasurement.Left) + left;
                            RPLItem      rPLItem   = array4[i] = rPLItemMeasurement.Element;
                            byte         b         = default(byte);
                            RPLItemProps itemProps = layout.RPLReport.GetItemProps(rPLItem.RPLSource, out b);
                            if (b == 7)
                            {
                                RPLTextBoxPropsDef rPLTextBoxPropsDef = (RPLTextBoxPropsDef)itemProps.Definition;
                                if (rPLTextBoxPropsDef.IsSimple)
                                {
                                    layout.AddReportItem(rPLItem.RPLSource, array2[i], array3[i], num3, num2, generationIndex, rPLItemMeasurement.State, subreportLanguage, toggleParents);
                                }
                                else
                                {
                                    layout.AddReportItem(rPLItem, array2[i], array3[i], num3, num2, generationIndex, rPLItemMeasurement.State, subreportLanguage, toggleParents);
                                }
                                if (!suppressOutlines && rPLTextBoxPropsDef.IsToggleParent && !toggleParents.ContainsKey(rPLTextBoxPropsDef.Name))
                                {
                                    toggleParents.Add(rPLTextBoxPropsDef.Name, new ToggleParent(array2[i], array3[i], num3, num2));
                                }
                            }
                            else
                            {
                                layout.AddReportItem(rPLItem.RPLSource, array2[i], array3[i], num3, num2, generationIndex, rPLItemMeasurement.State, subreportLanguage, toggleParents);
                            }
                        }
                    }
                    for (int j = 0; j < rPLContainer.Children.Length; j++)
                    {
                        if (rPLContainer.Children[j] != null)
                        {
                            Reader.ReadMeasurement(array4[j], layout, array2[j], array3[j], generationIndex + 1, blockOutlines, toggleParents, suppressOutlines, array[j], subreportLanguage);
                            rPLContainer.Children[j] = null;
                            array4[j] = null;
                        }
                    }
                    rPLContainer.Children = null;
                }
            }
            else
            {
                Reader.ReadTablixStructure(element as RPLTablix, layout, top, left, generationIndex, blockOutlines, toggleParents, suppressOutlines, subreportLanguage);
            }
        }
        public void RenderReportItem(RPLElement dynamicImage, RPLItemMeasurement measurement, StyleContext styleContext, ref int borderContext, bool renderId, bool treatAsTopLevel)
        {
            RPLElementProps      elementProps         = dynamicImage.ElementProps;
            RPLElementPropsDef   definition           = elementProps.Definition;
            RPLDynamicImageProps rPLDynamicImageProps = (RPLDynamicImageProps)elementProps;
            string tooltip = html5Renderer.GetTooltip(rPLDynamicImageProps);

            if (dynamicImage == null)
            {
                return;
            }
            bool      flag      = rPLDynamicImageProps.ActionImageMapAreas != null && rPLDynamicImageProps.ActionImageMapAreas.Length != 0;
            Rectangle rectangle = RenderDynamicImage(measurement, rPLDynamicImageProps);
            int       xOffset   = 0;
            int       yOffset   = 0;
            bool      flag2     = !rectangle.IsEmpty;
            bool      flag3     = !html5Renderer.m_deviceInfo.IsBrowserSafari || html5Renderer.m_deviceInfo.AllowScript || !styleContext.InTablix;

            if (flag3)
            {
                html5Renderer.WriteStream(HTMLElements.m_openDiv);
                if (flag2 && html5Renderer.m_elementExtender.ShouldApplyToElement(treatAsTopLevel))
                {
                    WriteReportItemDataName();
                }
                html5Renderer.WriteAccesibilityTags(RenderRes.AccessibleChartLabel, rPLDynamicImageProps, treatAsTopLevel);
                if (treatAsTopLevel)
                {
                    string accessibleAriaName = string.IsNullOrEmpty(tooltip) ? RenderRes.AccessibleChartLabel : RenderResWrapper.AccessibleChartNavigationGroupLabel(tooltip);
                    html5Renderer.WriteAriaAccessibleTags(accessibleAriaName);
                }
            }
            bool flag4 = html5Renderer.m_deviceInfo.DataVisualizationFitSizing == DataVisualizationFitSizing.Exact && styleContext.InTablix;

            if (flag2)
            {
                RPLFormat.Sizings sizing = flag4 ? RPLFormat.Sizings.Fit : RPLFormat.Sizings.AutoSize;
                html5Renderer.WriteOuterConsolidation(rectangle, sizing, rPLDynamicImageProps.UniqueName);
                html5Renderer.RenderReportItemStyle(dynamicImage, null, ref borderContext);
                xOffset = rectangle.Left;
                yOffset = rectangle.Top;
            }
            else if (flag4 && html5Renderer.m_deviceInfo.AllowScript)
            {
                if (html5Renderer.m_imgFitDivIdsStream == null)
                {
                    html5Renderer.CreateImgFitDivImageIdsStream();
                }
                html5Renderer.WriteIdToSecondaryStream(html5Renderer.m_imgFitDivIdsStream, rPLDynamicImageProps.UniqueName + "_ifd");
                html5Renderer.RenderReportItemId(rPLDynamicImageProps.UniqueName + "_ifd");
            }
            if (flag3)
            {
                html5Renderer.WriteStream(HTMLElements.m_closeBracket);
            }
            html5Renderer.WriteStream(HTMLElements.m_img);
            if (html5Renderer.m_elementExtender.ShouldApplyToElement(treatAsTopLevel))
            {
                if (!flag2)
                {
                    WriteReportItemDataName();
                }
                RPLItemPropsDef rPLItemPropsDef = (RPLItemPropsDef)definition;
                html5Renderer.WriteAttrEncoded(HTMLElements.m_reportItemCustomAttr, html5Renderer.GetReportItemPath(rPLItemPropsDef.Name));
            }
            if (html5Renderer.m_browserIE)
            {
                html5Renderer.WriteStream(HTMLElements.m_imgOnError);
            }
            if (renderId)
            {
                html5Renderer.RenderReportItemId(rPLDynamicImageProps.UniqueName);
            }
            html5Renderer.WriteStream(HTMLElements.m_zeroBorder);
            bool flag5 = dynamicImage is RPLChart;

            if (flag)
            {
                html5Renderer.WriteAttrEncoded(HTMLElements.m_useMap, "#" + html5Renderer.m_deviceInfo.HtmlPrefixId + HTMLElements.m_mapPrefixString + rPLDynamicImageProps.UniqueName);
                if (flag4)
                {
                    html5Renderer.OpenStyle();
                    if (html5Renderer.m_useInlineStyle && !flag2)
                    {
                        html5Renderer.WriteStream(HTMLElements.m_styleHeight);
                        html5Renderer.WriteStream(HTMLElements.m_percent);
                        html5Renderer.WriteStream(HTMLElements.m_semiColon);
                        html5Renderer.WriteStream(HTMLElements.m_styleWidth);
                        html5Renderer.WriteStream(HTMLElements.m_percent);
                        html5Renderer.WriteStream(HTMLElements.m_semiColon);
                        flag5 = false;
                    }
                    html5Renderer.WriteStream("border-style:none;");
                }
            }
            else if (flag4 && html5Renderer.m_useInlineStyle && !flag2)
            {
                html5Renderer.PercentSizes();
                flag5 = false;
            }
            StyleContext styleContext2 = new StyleContext();

            if (!flag4 && (html5Renderer.m_deviceInfo.IsBrowserIE7 || html5Renderer.m_deviceInfo.IsBrowserIE6))
            {
                styleContext2.RenderMeasurements    = false;
                styleContext2.RenderMinMeasurements = false;
            }
            if (!flag2)
            {
                if (flag4)
                {
                    html5Renderer.RenderReportItemStyle(dynamicImage, null, ref borderContext, styleContext2);
                }
                else if (flag5)
                {
                    RPLElementProps elementProps2 = dynamicImage.ElementProps;
                    StyleContext    styleContext3 = new StyleContext();
                    styleContext3.RenderMeasurements = false;
                    html5Renderer.OpenStyle();
                    html5Renderer.RenderMeasurementStyle(measurement.Height, measurement.Width);
                    html5Renderer.RenderReportItemStyle(dynamicImage, elementProps2, definition, measurement, styleContext3, ref borderContext, definition.ID);
                }
                else
                {
                    html5Renderer.RenderReportItemStyle(dynamicImage, measurement, ref borderContext, styleContext2);
                }
            }
            else
            {
                html5Renderer.WriteClippedDiv(rectangle);
            }
            tooltip = (string.IsNullOrEmpty(tooltip) ? RenderRes.AccessibleChartLabel : tooltip);
            html5Renderer.WriteToolTipAttribute(tooltip);
            html5Renderer.WriteStream(HTMLElements.m_src);
            html5Renderer.RenderDynamicImageSrc(rPLDynamicImageProps);
            html5Renderer.WriteStreamCR(HTMLElements.m_closeTag);
            if (flag)
            {
                html5Renderer.RenderImageMapAreas(rPLDynamicImageProps.ActionImageMapAreas, measurement.Width, measurement.Height, rPLDynamicImageProps.UniqueName, xOffset, yOffset);
            }
            if (flag3)
            {
                html5Renderer.WriteStream(HTMLElements.m_closeDiv);
            }
        }
Пример #23
0
 internal virtual void ProcessRenderingElementContent(RPLElement rplElement, GdiContext context, RectangleF bounds)
 {
 }