/// <summary> /// Returns the max of the given Margins, if both are positive or 0, the sum otherwise. /// </summary> /// <param name="prevBottomMargin">The bottom margin of the previous element.</param> /// <param name="nextTopMargin">The top margin of the next element.</param> /// <returns></returns> private XUnit MarginMax(XUnit prevBottomMargin, XUnit nextTopMargin) { if (prevBottomMargin >= 0 && nextTopMargin >= 0) return Math.Max(prevBottomMargin, nextTopMargin); else return prevBottomMargin + nextTopMargin; }
public static XGraphics NewPage(PdfDocument document, XUnit width, XUnit height) { var page = document.AddPage(); page.Width = width; page.Height = height; return XGraphics.FromPdfPage(page); }
internal void Render(XUnit x, XUnit y, XUnit width, XUnit height) { if (_shading == null || _brush == null) return; _gfx.DrawRectangle(_brush, x.Point, y.Point, width.Point, height.Point); }
/// <summary> /// Create new page /// </summary> void CreatePage() { Page = _document.AddPage(); Page.Size = PageSize.A4; Gfx = XGraphics.FromPdfPage(Page); _currentPosition = _topPosition; }
public Cell(string text, XUnit width, XFont font, Alignment alignment) { this.Text = text; this.width = width; this.font = font; this.alignment = alignment; this.height = XUnit.Zero; }
/// <summary> /// Constructor /// </summary> /// <param name="document">Pdf Document object</param> /// <param name="topPosition">Top positon for the PDF write start position</param> /// <param name="bottomMargin">Bottom margin for the PDF</param> public PDFLayoutHelper(PdfDocument document, XUnit topPosition, XUnit bottomMargin) { _document = document; _topPosition = topPosition; _bottomMargin = bottomMargin; // Set a value outside the page - a new page will be created on the first request. _currentPosition = bottomMargin + 10000; }
internal FormattedCell(Cell cell, DocumentRenderer documentRenderer, Borders cellBorders, FieldInfos fieldInfos, XUnit xOffset, XUnit yOffset) { this.cell = cell; this.fieldInfos = fieldInfos; this.yOffset = yOffset; this.xOffset = xOffset; this.bordersRenderer = new BordersRenderer(cellBorders, null); this.documentRenderer = documentRenderer; }
internal void Render(XUnit x, XUnit y, XUnit width, XUnit height) { XBrush brush = GetBrush(); if (brush == null) return; this.gfx.DrawRectangle(brush, x.Point, y.Point, width.Point, height.Point); }
internal void Render(XUnit xPosition, XUnit yPosition, XUnit width, XUnit height) { XUnit lineWidth = GetWidth(); if (lineWidth > 0) { XPen pen = GetPen(lineWidth); _gfx.DrawRectangle(pen, xPosition, yPosition, width, height); } }
internal FormattedCell(Cell cell, DocumentRenderer documentRenderer, Borders cellBorders, FieldInfos fieldInfos, XUnit xOffset, XUnit yOffset) { _cell = cell; _fieldInfos = fieldInfos; _yOffset = yOffset; _xOffset = xOffset; _bordersRenderer = new BordersRenderer(cellBorders, null); _documentRenderer = documentRenderer; }
public OHS_Page(PdfPage page, ProfileInfo userProfile, List<Parameter> userParameters) { this.page = page; this.userProfile = userProfile; foreach (Parameter p in userParameters) this.userParameters.Add(p.Name, p); quaterWidth = page.Width / 4; }
/// <summary> /// Get line positon for current write position /// </summary> /// <param name="requestedHeight">Requested height for next line</param> /// <param name="requiredHeight">Required height for next line</param> /// <returns></returns> public XUnit GetLinePosition(XUnit requestedHeight, XUnit requiredHeight) { XUnit required = requiredHeight == -1f ? requestedHeight : requiredHeight; // Check if new line position will exceed the page limit, if then create a new page if (_currentPosition + required > _bottomMargin) CreatePage(); XUnit result = _currentPosition; _currentPosition += requestedHeight; return result; }
FormattedTextArea GetFormattedTextArea(TextArea area, XUnit width) { if (area == null) return null; FormattedTextArea formattedTextArea = new FormattedTextArea(_documentRenderer, area, _fieldInfos); if (!double.IsNaN(width)) formattedTextArea.InnerWidth = width; formattedTextArea.Format(_gfx); return formattedTextArea; }
void GetLeftRightVerticalPosition(out XUnit top, out XUnit bottom) { //REM: Line width is still ignored while layouting charts. Area contentArea = _renderInfo.LayoutInfo.ContentArea; ChartFormatInfo formatInfo = (ChartFormatInfo)_renderInfo.FormatInfo; top = contentArea.Y; if (formatInfo.FormattedHeader != null) top += formatInfo.FormattedHeader.InnerHeight; bottom = contentArea.Y + contentArea.Height; if (formatInfo.FormattedFooter != null) bottom -= formatInfo.FormattedFooter.InnerHeight; }
/// <summary> /// Renders the contents shifted to the given Coordinates. /// </summary> /// <param name="xShift">The x shift.</param> /// <param name="yShift">The y shift.</param> /// <param name="renderInfos">The render infos.</param> protected void RenderByInfos(XUnit xShift, XUnit yShift, RenderInfo[] renderInfos) { if (renderInfos == null) return; foreach (RenderInfo renderInfo in renderInfos) { XUnit savedX = renderInfo.LayoutInfo.ContentArea.X; XUnit savedY = renderInfo.LayoutInfo.ContentArea.Y; renderInfo.LayoutInfo.ContentArea.X += xShift; renderInfo.LayoutInfo.ContentArea.Y += yShift; Renderer renderer = Create(_gfx, _documentRenderer, renderInfo, _fieldInfos); renderer.Render(); renderInfo.LayoutInfo.ContentArea.X = savedX; renderInfo.LayoutInfo.ContentArea.Y = savedY; } }
internal void Render(XUnit x, XUnit y, XUnit width, XUnit height, RoundedCorner roundedCorner) { // If there is no rounded corner, we can use the usual Render method. if (roundedCorner == RoundedCorner.None) { Render(x, y, width, height); return; } if (_shading == null || _brush == null) return; XGraphicsPath path = new XGraphicsPath(); switch (roundedCorner) { case RoundedCorner.TopLeft: path.AddArc(new XRect(x, y, width * 2, height * 2), 180, 90); // Error in CORE: _corePath.AddArc(). path.AddLine(new XPoint(x + width, y), new XPoint(x + width, y + height)); break; case RoundedCorner.TopRight: path.AddArc(new XRect(x - width, y, width * 2, height * 2), 270, 90); // Error in CORE: _corePath.AddArc(). path.AddLine(new XPoint(x + width, y + height), new XPoint(x, y + height)); break; case RoundedCorner.BottomRight: path.AddArc(new XRect(x - width, y - height, width * 2, height * 2), 0, 90); // Error in CORE: _corePath.AddArc(). path.AddLine(new XPoint(x, y + height), new XPoint(x, y)); break; case RoundedCorner.BottomLeft: path.AddArc(new XRect(x, y - height, width * 2, height * 2), 90, 90); // Error in CORE: _corePath.AddArc(). path.AddLine(new XPoint(x, y), new XPoint(x + width, y)); break; } path.CloseFigure(); _gfx.DrawPath(_brush, path); }
void RestoreAfterProbing(ParagraphIterator paragraphIter, int blankCount, XUnit wordsWidth, XUnit xPosition, XUnit lineWidth, XUnit blankWidth) { this.currentLeaf = paragraphIter; this.currentBlankCount = blankCount; this.currentXPosition = xPosition; this.currentLineWidth = lineWidth; this.currentWordsWidth = wordsWidth; this.savedBlankWidth = blankWidth; }
void SaveBeforeProbing(out ParagraphIterator paragraphIter, out int blankCount, out XUnit wordsWidth, out XUnit xPosition, out XUnit lineWidth, out XUnit blankWidth) { paragraphIter = this.currentLeaf; blankCount = this.currentBlankCount; xPosition = this.currentXPosition; lineWidth = this.currentLineWidth; wordsWidth = this.currentWordsWidth; blankWidth = this.savedBlankWidth; }
/// <summary> /// Probes the paragraph elements after a right aligned tab stop and returns the vertical text position to start at. /// </summary> /// <param name="tabStopPosition">Position of the tab to probe.</param> /// <param name="notFitting">Out parameter determining whether the tab causes a line break.</param> /// <returns>The new x-position to restart behind the tab.</returns> XUnit ProbeAfterDecimalAlignedTab(XUnit tabStopPosition, out bool notFitting) { notFitting = false; ParagraphIterator savedLeaf = this.currentLeaf; //Extra for auto tab after list symbol if (IsTab(this.currentLeaf.Current)) this.currentLeaf = this.currentLeaf.GetNextLeaf(); if (this.currentLeaf == null) { this.currentLeaf = savedLeaf; return this.currentXPosition + tabStopPosition; } VerticalLineInfo newVerticalInfo = CalcCurrentVerticalInfo(); Rectangle fittingRect = this.formattingArea.GetFittingRect(this.currentYPosition, newVerticalInfo.height); if (fittingRect == null) { notFitting = true; this.currentLeaf = savedLeaf; return this.currentXPosition; } if (IsPlainText(this.currentLeaf.Current)) { Text text = (Text)this.currentLeaf.Current; string word = text.Content; int lastIndex = text.Content.LastIndexOfAny(new char[] { ',', '.' }); if (lastIndex > 0) word = word.Substring(0, lastIndex); XUnit wordLength = MeasureString(word); notFitting = this.currentXPosition + wordLength >= formattingArea.X + formattingArea.Width + Tolerance; if (!notFitting) return this.formattingArea.X + tabStopPosition - wordLength; else return this.currentXPosition; } this.currentLeaf = savedLeaf; return ProbeAfterRightAlignedTab(tabStopPosition, out notFitting); }
internal TabOffset(TabLeader leader, XUnit offset) { this.leader = leader; this.offset = offset; }
/// <summary> /// Probes the paragraph elements after a right aligned tab stop and returns the vertical text position to start at. /// </summary> /// <param name="tabStopPosition">Position of the tab to probe.</param> /// <param name="notFitting">Out parameter determining whether the tab causes a line break.</param> /// <returns>The new x-position to restart behind the tab.</returns> XUnit ProbeAfterCenterAlignedTab(XUnit tabStopPosition, out bool notFitting) { //--- Save --------------------------------- ParagraphIterator iter; int blankCount; XUnit xPosition; XUnit lineWidth; XUnit wordsWidth; XUnit blankWidth; SaveBeforeProbing(out iter, out blankCount, out wordsWidth, out xPosition, out lineWidth, out blankWidth); //------------------------------------------ XUnit xPositionAfterTab = xPosition; notFitting = ProbeAfterTab(); if (!notFitting) { if (xPosition + this.currentLineWidth / 2.0 <= this.formattingArea.X + tabStopPosition) { Rectangle rect = this.formattingArea.GetFittingRect(this.currentYPosition, this.currentVerticalInfo.height); if (this.formattingArea.X + tabStopPosition + this.currentLineWidth / 2.0 > rect.X + rect.Width - this.RightIndent) { //the text is too long on the right hand side of the tabstop => align to right indent. xPositionAfterTab = rect.X + rect.Width - this.RightIndent - this.currentLineWidth; } else xPositionAfterTab = this.formattingArea.X + tabStopPosition - this.currentLineWidth / 2; } } //--- Restore ------------------------------ RestoreAfterProbing(iter, blankCount, wordsWidth, xPosition, lineWidth, blankWidth); //------------------------------------------ return xPositionAfterTab; }
/// <summary> /// Initializes a new instance of the <see cref="XForm"/> class that represents a page of a PDF document. /// </summary> /// <param name="document">The PDF document.</param> /// <param name="width">The width of the page.</param> /// <param name="height">The height of the page</param> public XForm(PdfDocument document, XUnit width, XUnit height) : this(document, new XRect(0, 0, width, height)) { }
internal void Format(XGraphics gfx) { this.gfx = gfx; this.isFirstArea = true; this.formatter = new TopDownFormatter(this, this.documentRenderer, this.headerFooter.Elements); this.formatter.FormatOnAreas(gfx, false); this.contentHeight = RenderInfo.GetTotalHeight(GetRenderInfos()); }
void StartUnderline(XUnit xPosition) { this.underlineStartPos = xPosition; }
void RenderUnderline(XUnit width, bool isWord) { XPen pen = GetUnderlinePen(isWord); bool penChanged = UnderlinePenChanged(pen); if (penChanged) { if (this.currentUnderlinePen != null) EndUnderline(this.currentUnderlinePen, this.currentXPosition); if (pen != null) StartUnderline(this.currentXPosition); this.currentUnderlinePen = pen; } if (this.currentLeaf.Current == this.endLeaf.Current) { if (this.currentUnderlinePen != null) EndUnderline(this.currentUnderlinePen, this.currentXPosition + width); this.currentUnderlinePen = null; } }
VerticalLineInfo CalcVerticalInfo(XFont font) { ParagraphFormat paragraphFormat = this.paragraph.Format; LineSpacingRule spacingRule = paragraphFormat.LineSpacingRule; XUnit lineHeight = 0; XUnit descent = FontHandler.GetDescent(font); descent = Math.Max(this.currentVerticalInfo.descent, descent); XUnit singleLineSpace = font.GetHeight(); RenderInfo imageRenderInfo = this.CurrentImageRenderInfo; if (imageRenderInfo != null) singleLineSpace = singleLineSpace - FontHandler.GetAscent(font) + imageRenderInfo.LayoutInfo.ContentArea.Height; XUnit inherentLineSpace = Math.Max(this.currentVerticalInfo.inherentlineSpace, singleLineSpace); switch (spacingRule) { case LineSpacingRule.Single: lineHeight = singleLineSpace; break; case LineSpacingRule.OnePtFive: lineHeight = 1.5 * singleLineSpace; break; case LineSpacingRule.Double: lineHeight = 2.0 * singleLineSpace; break; case LineSpacingRule.Multiple: lineHeight = this.paragraph.Format.LineSpacing * singleLineSpace; break; case LineSpacingRule.AtLeast: lineHeight = Math.Max(singleLineSpace, paragraph.Format.LineSpacing); break; case LineSpacingRule.Exactly: lineHeight = new XUnit(paragraph.Format.LineSpacing); inherentLineSpace = paragraph.Format.LineSpacing.Point; break; } lineHeight = Math.Max(this.currentVerticalInfo.height, lineHeight); if (this.MaxElementHeight > 0) lineHeight = Math.Min(this.MaxElementHeight - Renderer.Tolerance, lineHeight); return new VerticalLineInfo(lineHeight, descent, inherentLineSpace); }
/// <summary> /// Stores all line information. /// </summary> void StoreLineInformation() { PopSavedBlankWidth(); XUnit topBorderOffset = TopBorderOffset; Area contentArea = this.renderInfo.LayoutInfo.ContentArea; if (topBorderOffset > 0)//May only occure for the first line. contentArea = this.formattingArea.GetFittingRect(this.formattingArea.Y, topBorderOffset); if (contentArea == null) { contentArea = this.formattingArea.GetFittingRect(this.currentYPosition, this.currentVerticalInfo.height); } else contentArea = contentArea.Unite(this.formattingArea.GetFittingRect(this.currentYPosition, this.currentVerticalInfo.height)); XUnit bottomBorderOffset = this.BottomBorderOffset; if (bottomBorderOffset > 0) contentArea = contentArea.Unite(this.formattingArea.GetFittingRect(this.currentYPosition + this.currentVerticalInfo.height, bottomBorderOffset)); LineInfo lineInfo = new LineInfo(); lineInfo.vertical = this.currentVerticalInfo; if (this.startLeaf != null && this.startLeaf == this.currentLeaf) HandleNonFittingLine(); lineInfo.lastTab = this.lastTab; this.renderInfo.LayoutInfo.ContentArea = contentArea; lineInfo.startIter = this.startLeaf; if (this.currentLeaf == null) lineInfo.endIter = new ParagraphIterator(this.paragraph.Elements).GetLastLeaf(); else lineInfo.endIter = this.currentLeaf.GetPreviousLeaf(); lineInfo.blankCount = this.currentBlankCount; lineInfo.wordsWidth = this.currentWordsWidth; lineInfo.lineWidth = this.currentLineWidth; lineInfo.tabOffsets = this.tabOffsets; lineInfo.reMeasureLine = this.reMeasureLine; this.savedWordWidth = 0; this.reMeasureLine = false; ((ParagraphFormatInfo)this.renderInfo.FormatInfo).AddLineInfo(lineInfo); }
/// <summary> /// Initializes a new instance of the XForm class such that it can be drawn on the specified graphics /// object. /// </summary> /// <param name="gfx">The graphics object that later is used to draw this form.</param> /// <param name="width">The width of the form.</param> /// <param name="height">The height of the form.</param> public XForm(XGraphics gfx, XUnit width, XUnit height) : this(gfx, new XSize(width, height)) { }
/// <summary> /// This member is intended to be used by XmlDomainObjectReader only. /// </summary> public static XUnit Parse(string value) { XUnit unit = value; return(unit); }
XPen GetPen(XUnit width) { if (width == 0) return null; XPen pen = new XPen(GetColor(), width); switch (_lineFormat.DashStyle) { case DashStyle.Dash: pen.DashStyle = XDashStyle.Dash; break; case DashStyle.DashDot: pen.DashStyle = XDashStyle.DashDot; break; case DashStyle.DashDotDot: pen.DashStyle = XDashStyle.DashDotDot; break; case DashStyle.Solid: pen.DashStyle = XDashStyle.Solid; break; case DashStyle.SquareDot: pen.DashStyle = XDashStyle.Dot; break; } return pen; }
void EndUnderline(XPen pen, XUnit xPosition) { //Removed KlPo 06.06.07 //XUnit yPosition = this.currentYPosition + this.currentVerticalInfo.height + pen.Width / 2; //yPosition -= 0.66 * this.currentVerticalInfo.descent; //New KlPo XUnit yPosition = CurrentBaselinePosition; yPosition += 0.33 * this.currentVerticalInfo.descent; this.gfx.DrawLine(pen, this.underlineStartPos, yPosition, xPosition, yPosition); }
Size GetSizeOfPage(int page, out XUnit width, out XUnit height) { PageInfo pageInfo = _renderer.FormattedDocument.GetPageInfo(page); if (pageInfo.Orientation == PdfSharp.PageOrientation.Portrait) { width = pageInfo.Width; height = pageInfo.Height; } else { width = pageInfo.Height; height = pageInfo.Width; } return new Size(width.Presentation, height.Presentation); }
/// <summary> /// Probes the paragraph elements after a right aligned tab stop and returns the vertical text position to start at. /// </summary> /// <param name="tabStopPosition">Position of the tab to probe.</param> /// <param name="notFitting">Out parameter determining whether the tab causes a line break.</param> /// <returns>The new x-position to restart behind the tab.</returns> XUnit ProbeAfterRightAlignedTab(XUnit tabStopPosition, out bool notFitting) { //--- Save --------------------------------- ParagraphIterator iter; int blankCount; XUnit xPosition; XUnit lineWidth; XUnit wordsWidth; XUnit blankWidth; SaveBeforeProbing(out iter, out blankCount, out wordsWidth, out xPosition, out lineWidth, out blankWidth); //------------------------------------------ XUnit xPositionAfterTab = xPosition; notFitting = ProbeAfterTab(); if (!notFitting && xPosition + this.currentLineWidth <= this.formattingArea.X + tabStopPosition) xPositionAfterTab = this.formattingArea.X + tabStopPosition - this.currentLineWidth; //--- Restore ------------------------------ RestoreAfterProbing(iter, blankCount, wordsWidth, xPosition, lineWidth, blankWidth); //------------------------------------------ return xPositionAfterTab; }