kua-agent
6610acfa44
- Services/PdfRedactText.cs: strip text whose origin falls inside a CoverAnnotation from the page content stream at save time, hooked into PdfBurn.DrawAnnotationsIntoDoc. Fixes edited values staying recoverable by text extraction. - Themes/MMD.xaml replaces all thirteen themes; picker and accent strip removed; no dark mode. - Rename KillerPDF -> MMD PDF across code, resources, packaging and locale strings; new icon. - Remove the upstream author credit and the in-app install button.
467 lines
17 KiB
C#
467 lines
17 KiB
C#
#region PDFsharp - A .NET library for processing PDF
|
|
//
|
|
// Authors:
|
|
// Stefan Lange
|
|
//
|
|
// Copyright (c) 2005-2016 empira Software GmbH, Cologne Area (Germany)
|
|
//
|
|
// http://www.PdfSharp.com
|
|
// http://sourceforge.net/projects/pdfsharp
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the "Software"),
|
|
// to deal in the Software without restriction, including without limitation
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
// and/or sell copies of the Software, and to permit persons to whom the
|
|
// Software is furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
// DEALINGS IN THE SOFTWARE.
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using PdfSharpCore.Drawing.Layout.enums;
|
|
using PdfSharpCore.Pdf.IO;
|
|
|
|
namespace PdfSharpCore.Drawing.Layout
|
|
{
|
|
/// <summary>
|
|
/// Represents a very simple text formatter.
|
|
/// If this class does not satisfy your needs on formatting paragraphs I recommend to take a look
|
|
/// at MigraDoc Foundation. Alternatively you should copy this class in your own source code and modify it.
|
|
/// </summary>
|
|
public class XTextFormatter
|
|
{
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="XTextFormatter"/> class.
|
|
/// </summary>
|
|
public XTextFormatter(XGraphics gfx)
|
|
{
|
|
if (gfx == null)
|
|
throw new ArgumentNullException("gfx");
|
|
_gfx = gfx;
|
|
}
|
|
readonly XGraphics _gfx;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the text.
|
|
/// </summary>
|
|
/// <value>The text.</value>
|
|
public string Text
|
|
{
|
|
get { return _text; }
|
|
set { _text = value; }
|
|
}
|
|
string _text;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the font.
|
|
/// </summary>
|
|
public XFont Font
|
|
{
|
|
get { return _font; }
|
|
set
|
|
{
|
|
if (value == null)
|
|
throw new ArgumentNullException("Font");
|
|
_font = value;
|
|
|
|
_lineSpace = _font.GetHeight(); // old: _font.GetHeight(_gfx);
|
|
_cyAscent = _lineSpace * _font.CellAscent / _font.CellSpace;
|
|
_cyDescent = _lineSpace * _font.CellDescent / _font.CellSpace;
|
|
|
|
// HACK in XTextFormatter
|
|
_spaceWidth = _gfx.MeasureString("x x", value).Width;
|
|
_spaceWidth -= _gfx.MeasureString("xx", value).Width;
|
|
}
|
|
}
|
|
XFont _font;
|
|
double _lineSpace;
|
|
double _cyAscent;
|
|
double _cyDescent;
|
|
double _spaceWidth;
|
|
double _lineHeight;
|
|
|
|
// MmdPdf patch: removed unused _textLayout field (upstream dead code, CS0169)
|
|
|
|
/// <summary>
|
|
/// Gets or sets the bounding box of the layout.
|
|
/// </summary>
|
|
public XRect LayoutRectangle
|
|
{
|
|
get { return _layoutRectangle; }
|
|
set { _layoutRectangle = value; }
|
|
}
|
|
XRect _layoutRectangle;
|
|
|
|
/// <summary>
|
|
/// When true, ignore the height of text areas when rendering multiline strings
|
|
/// </summary>
|
|
public bool AllowVerticalOverflow { get; set; } = false;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the horizontal alignment of the text.
|
|
/// </summary>
|
|
public XParagraphAlignment Alignment { get; set; } = XParagraphAlignment.Left;
|
|
|
|
/// <summary>
|
|
/// Gets or sets the vertical alignment of the text.
|
|
/// </summary>
|
|
public XVerticalAlignment VerticalAlignment { get; set; } = XVerticalAlignment.Top;
|
|
|
|
/// <summary>
|
|
/// Set vertical and horizontal alignment
|
|
/// </summary>
|
|
/// <param name="alignments"></param>
|
|
public void SetAlignment(TextFormatAlignment alignments)
|
|
{
|
|
Alignment = alignments.Horizontal;
|
|
VerticalAlignment = alignments.Vertical;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Draws the text.
|
|
/// </summary>
|
|
/// <param name="text">The text to be drawn.</param>
|
|
/// <param name="font">The font.</param>
|
|
/// <param name="brush">The text brush.</param>
|
|
/// <param name="layoutRectangle">The layout rectangle.</param>
|
|
/// <param name="lineHeight">The line height.</param>
|
|
public void DrawString(string text, XFont font, XBrush brush, XRect layoutRectangle, XUnit? lineHeight = null)
|
|
{
|
|
DrawString(text, font, brush, layoutRectangle, new TextFormatAlignment()
|
|
{
|
|
Horizontal = XParagraphAlignment.Justify, Vertical = XVerticalAlignment.Top
|
|
}, lineHeight);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the layout rectangle required.
|
|
/// </summary>
|
|
/// <param name="text">The text to be drawn.</param>
|
|
/// <param name="font">The font.</param>
|
|
/// <param name="brush">The text brush.</param>
|
|
/// <param name="layoutRectangle">The layout rectangle.</param>
|
|
/// <param name="lineHeight">The height of each line</param>
|
|
public XRect GetLayout(string text, XFont font, XBrush brush, XRect layoutRectangle,
|
|
XUnit? lineHeight = null)
|
|
{
|
|
if (text == null)
|
|
throw new ArgumentNullException("text");
|
|
if (font == null)
|
|
throw new ArgumentNullException("font");
|
|
if (brush == null)
|
|
throw new ArgumentNullException("brush");
|
|
|
|
Text = text;
|
|
Font = font;
|
|
LayoutRectangle = layoutRectangle;
|
|
|
|
_lineHeight = lineHeight?.Point ?? _lineSpace;
|
|
|
|
if (text.Length == 0)
|
|
return new XRect(layoutRectangle.Location.X, layoutRectangle.Location.Y, 0, 0);
|
|
|
|
CreateBlocks();
|
|
|
|
CreateLayout();
|
|
|
|
return _layoutRectangle;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Draws the text.
|
|
/// </summary>
|
|
/// <param name="text">The text to be drawn.</param>
|
|
/// <param name="font">The font.</param>
|
|
/// <param name="brush">The text brush.</param>
|
|
/// <param name="layoutRectangle">The layout rectangle.</param>
|
|
/// <param name="alignments">The alignments.</c></param>
|
|
/// <param name="lineHeight">The height of each line.</param>
|
|
public void DrawString(string text, XFont font, XBrush brush, XRect layoutRectangle, TextFormatAlignment alignments,
|
|
XUnit? lineHeight = null)
|
|
{
|
|
if (alignments == null)
|
|
throw new ArgumentNullException(nameof(alignments));
|
|
|
|
if (text.Length == 0)
|
|
return;
|
|
|
|
GetLayout(text, font, brush, layoutRectangle, lineHeight);
|
|
|
|
SetAlignment(alignments);
|
|
|
|
double dx = layoutRectangle.Location.X;
|
|
double dy = layoutRectangle.Location.Y;
|
|
|
|
var lines = GetLines(_blocks).ToArray();
|
|
|
|
if (VerticalAlignment == XVerticalAlignment.Middle)
|
|
{
|
|
dy += (layoutRectangle.Height - _layoutRectangle.Height) / 2;
|
|
}
|
|
else if (VerticalAlignment == XVerticalAlignment.Bottom)
|
|
{
|
|
dy = layoutRectangle.Location.Y + layoutRectangle.Height - _layoutRectangle.Height + _lineHeight -
|
|
_cyDescent;
|
|
}
|
|
|
|
int count = _blocks.Count;
|
|
foreach (var line in lines)
|
|
{
|
|
var lineBlocks = line as Block[] ?? line.ToArray();
|
|
if (Alignment == XParagraphAlignment.Justify)
|
|
{
|
|
// LineBreak blocks carry no text (the Block(BlockType) ctor never sets Text) and
|
|
// CreateLayout never assigns them a Location, so they keep XPoint(0,0) and
|
|
// GetLines' GroupBy lumps them in with the first line. Drawing one dereferenced
|
|
// null and threw. They have nothing to render - skip them.
|
|
var drawable = lineBlocks.Where(b => b.Type != BlockType.LineBreak && b.Text != null).ToArray();
|
|
if (drawable.Length == 0)
|
|
continue;
|
|
|
|
var locationX = dx;
|
|
// A single-block line has no gaps to distribute; dividing by zero here yielded
|
|
// Infinity and pushed every following block off the page.
|
|
var gapSize = drawable.Length > 1
|
|
? (layoutRectangle.Width - drawable.Select(l => l.Width).Sum()) / (drawable.Length - 1)
|
|
: 0;
|
|
foreach (var block in drawable)
|
|
{
|
|
_gfx.DrawString(block.Text.Trim(), font, brush, locationX, dy + drawable.First().Location.Y, XStringFormats.TopLeft);
|
|
locationX += block.Width + gapSize;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var lineText = string.Join(" ", lineBlocks.Select(l => l.Text));
|
|
var locationX = dx;
|
|
if (Alignment == XParagraphAlignment.Center)
|
|
locationX = dx + layoutRectangle.Width / 2;
|
|
if (Alignment == XParagraphAlignment.Right)
|
|
locationX += layoutRectangle.Width;
|
|
_gfx.DrawString(lineText, font, brush, locationX, dy + lineBlocks.First().Location.Y, GetXStringFormat());
|
|
}
|
|
}
|
|
}
|
|
|
|
private static IEnumerable<IEnumerable<Block>> GetLines(List<Block> blocks)
|
|
{
|
|
return blocks.GroupBy(b => b.Location.Y);
|
|
}
|
|
|
|
void CreateBlocks()
|
|
{
|
|
_blocks.Clear();
|
|
int length = _text.Length;
|
|
bool inNonWhiteSpace = false;
|
|
int startIndex = 0, blockLength = 0;
|
|
for (int idx = 0; idx < length; idx++)
|
|
{
|
|
char ch = _text[idx];
|
|
|
|
// Treat CR and CRLF as LF
|
|
if (ch == Chars.CR)
|
|
{
|
|
if (idx < length - 1 && _text[idx + 1] == Chars.LF)
|
|
idx++;
|
|
ch = Chars.LF;
|
|
}
|
|
if (ch == Chars.LF)
|
|
{
|
|
if (blockLength != 0)
|
|
{
|
|
string token = _text.Substring(startIndex, blockLength);
|
|
_blocks.Add(new Block(token, BlockType.Text,
|
|
_gfx.MeasureString(token, _font).Width));
|
|
}
|
|
startIndex = idx + 1;
|
|
blockLength = 0;
|
|
_blocks.Add(new Block(BlockType.LineBreak));
|
|
}
|
|
else if (char.IsWhiteSpace(ch))
|
|
{
|
|
if (inNonWhiteSpace)
|
|
{
|
|
string token = _text.Substring(startIndex, blockLength);
|
|
_blocks.Add(new Block(token, BlockType.Text,
|
|
_gfx.MeasureString(token, _font).Width));
|
|
startIndex = idx + 1;
|
|
blockLength = 0;
|
|
}
|
|
else
|
|
{
|
|
blockLength++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
inNonWhiteSpace = true;
|
|
blockLength++;
|
|
}
|
|
}
|
|
if (blockLength != 0)
|
|
{
|
|
string token = _text.Substring(startIndex, blockLength);
|
|
_blocks.Add(new Block(token, BlockType.Text,
|
|
_gfx.MeasureString(token, _font).Width));
|
|
}
|
|
}
|
|
|
|
void CreateLayout()
|
|
{
|
|
double rectWidth = _layoutRectangle.Width;
|
|
double rectHeight = _layoutRectangle.Height - _cyAscent - _cyDescent;
|
|
int firstIndex = 0;
|
|
double x = 0, y = 0;
|
|
int count = _blocks.Count;
|
|
for (int idx = 0; idx < count; idx++)
|
|
{
|
|
Block block = _blocks[idx];
|
|
if (block.Type == BlockType.LineBreak)
|
|
{
|
|
if (Alignment == XParagraphAlignment.Justify)
|
|
_blocks[firstIndex].Alignment = XParagraphAlignment.Left;
|
|
HorizontalAlignLine(firstIndex, idx - 1, rectWidth);
|
|
firstIndex = idx + 1;
|
|
x = 0;
|
|
y += _lineHeight;
|
|
if (!AllowVerticalOverflow && y > rectHeight)
|
|
{
|
|
block.Stop = true;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double width = block.Width;
|
|
if ((x + width <= rectWidth || x == 0) && block.Type != BlockType.LineBreak)
|
|
{
|
|
block.Location = new XPoint(x, y);
|
|
x += width + _spaceWidth;
|
|
}
|
|
else
|
|
{
|
|
HorizontalAlignLine(firstIndex, idx - 1, rectWidth);
|
|
|
|
// Begin implicit line break
|
|
firstIndex = idx;
|
|
y += _lineHeight;
|
|
if (!AllowVerticalOverflow && y > rectHeight)
|
|
{
|
|
block.Stop = true;
|
|
break;
|
|
}
|
|
block.Location = new XPoint(0, y);
|
|
x = width + _spaceWidth;
|
|
}
|
|
}
|
|
}
|
|
if (firstIndex < count && Alignment != XParagraphAlignment.Justify)
|
|
HorizontalAlignLine(firstIndex, count - 1, rectWidth);
|
|
|
|
var minY = _blocks.Min(b => b.Location.Y);
|
|
var maxY = _blocks.Max(b => b.Location.Y + _lineHeight);
|
|
var minX = _blocks.Min(b => b.Location.X);
|
|
var maxX = _blocks.Max(b => b.Location.X + b.Width);
|
|
_layoutRectangle = new XRect
|
|
{
|
|
X = minX,
|
|
Y = minY,
|
|
Height = maxY - minY,
|
|
Width = maxX - minX
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Align center, right, or justify.
|
|
/// </summary>
|
|
void HorizontalAlignLine(int firstIndex, int lastIndex, double layoutWidth)
|
|
{
|
|
XParagraphAlignment blockAlignment = _blocks[firstIndex].Alignment;
|
|
if (Alignment == XParagraphAlignment.Left || blockAlignment == XParagraphAlignment.Left)
|
|
return;
|
|
|
|
int count = lastIndex - firstIndex + 1;
|
|
if (count == 0)
|
|
return;
|
|
|
|
double totalWidth = -_spaceWidth;
|
|
for (int idx = firstIndex; idx <= lastIndex; idx++)
|
|
totalWidth += _blocks[idx].Width + _spaceWidth;
|
|
|
|
double dx = Math.Max(layoutWidth - totalWidth, 0);
|
|
//Debug.Assert(dx >= 0);
|
|
if (Alignment != XParagraphAlignment.Justify)
|
|
{
|
|
if (Alignment == XParagraphAlignment.Center)
|
|
dx /= 2;
|
|
for (int idx = firstIndex; idx <= lastIndex; idx++)
|
|
{
|
|
Block block = _blocks[idx];
|
|
block.Location += new XSize(dx, 0);
|
|
}
|
|
}
|
|
else if (count > 1) // case: justify
|
|
{
|
|
dx /= count - 1;
|
|
for (int idx = firstIndex + 1, i = 1; idx <= lastIndex; idx++, i++)
|
|
{
|
|
Block block = _blocks[idx];
|
|
block.Location += new XSize(dx * i, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
readonly List<Block> _blocks = new List<Block>();
|
|
|
|
// TODO:
|
|
// - more XStringFormat variations
|
|
// - left and right indent
|
|
// - first line indent
|
|
// - margins and paddings
|
|
// - background color
|
|
// - text background color
|
|
// - border style
|
|
// - hyphens, soft hyphens, hyphenation
|
|
// - kerning
|
|
// - change font, size, text color etc.
|
|
// - underline and strike-out variation
|
|
// - super- and sub-script
|
|
// - ...
|
|
|
|
private XStringFormat GetXStringFormat()
|
|
{
|
|
switch (Alignment)
|
|
{
|
|
case XParagraphAlignment.Center:
|
|
return XStringFormats.TopCenter;
|
|
case XParagraphAlignment.Right:
|
|
return XStringFormats.TopRight;
|
|
case XParagraphAlignment.Default:
|
|
case XParagraphAlignment.Justify:
|
|
case XParagraphAlignment.Left:
|
|
default:
|
|
return XStringFormats.TopLeft;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class TextFormatAlignment
|
|
{
|
|
public XParagraphAlignment Horizontal { get; set; } = XParagraphAlignment.Left;
|
|
public XVerticalAlignment Vertical { get; set; } = XVerticalAlignment.Top;
|
|
}
|
|
}
|