public void ApplyXObject(NameToken xObjectName)
{
var xObjectStream = resourceStore.GetXObject(xObjectName);
// For now we will determine the type and store the object with the graphics state information preceding it.
// Then consumers of the page can request the object(s) to be retrieved by type.
var subType = (NameToken)xObjectStream.StreamDictionary.Data[NameToken.Subtype.Data];
var state = GetCurrentState();
var matrix = state.CurrentTransformationMatrix;
if (subType.Equals(NameToken.Ps))
{
xObjects[XObjectType.PostScript].Add(new XObjectContentRecord(XObjectType.PostScript, xObjectStream, matrix, state.RenderingIntent));
}
else if (subType.Equals(NameToken.Image))
{
images.Add(Union <XObjectContentRecord, InlineImage> .One(new XObjectContentRecord(XObjectType.Image, xObjectStream, matrix, state.RenderingIntent)));
}
else if (subType.Equals(NameToken.Form))
{
ProcessFormXObject(xObjectStream);
}
else
{
throw new InvalidOperationException($"XObject encountered with unexpected SubType {subType}. {xObjectStream.StreamDictionary}.");
}
}
private static bool TryExtendedColorSpaceNameMapping(NameToken name, out ColorSpace result)
{
result = ColorSpace.DeviceGray;
switch (name.Data)
{
case "G":
result = ColorSpace.DeviceGray;
return(true);
case "RGB":
result = ColorSpace.DeviceRGB;
return(true);
case "CMYK":
result = ColorSpace.DeviceCMYK;
return(true);
case "I":
result = ColorSpace.Indexed;
return(true);
}
return(false);
}
public static bool TryMap(NameToken name, IResourceStore resourceStore, out ColorSpace colorSpaceResult)
{
if (name.TryMapToColorSpace(out colorSpaceResult))
{
return(true);
}
if (TryExtendedColorSpaceNameMapping(name, out colorSpaceResult))
{
return(true);
}
if (!resourceStore.TryGetNamedColorSpace(name, out var colorSpaceNamedToken))
{
return(false);
}
if (colorSpaceNamedToken.Name.TryMapToColorSpace(out colorSpaceResult))
{
return(true);
}
if (TryExtendedColorSpaceNameMapping(colorSpaceNamedToken.Name, out colorSpaceResult))
{
return(true);
}
return(false);
}
public MarkedContentElement(int markedContentIdentifier, NameToken tag, DictionaryToken properties,
string language,
string actualText,
string alternateDescription,
string expandedForm,
bool isArtifact,
IReadOnlyList <MarkedContentElement> children,
IReadOnlyList <Letter> letters,
IReadOnlyList <PdfPath> paths,
IReadOnlyList <IPdfImage> images,
int index)
{
MarkedContentIdentifier = markedContentIdentifier;
Tag = tag;
Language = language;
ActualText = actualText;
AlternateDescription = alternateDescription;
ExpandedForm = expandedForm;
Properties = properties ?? new DictionaryToken(new Dictionary <NameToken, IToken>());
IsArtifact = isArtifact;
Children = children ?? throw new ArgumentNullException(nameof(children));
Letters = letters ?? throw new ArgumentNullException(nameof(letters));
Paths = paths ?? throw new ArgumentNullException(nameof(paths));
Images = images ?? throw new ArgumentNullException(nameof(images));
Index = index;
}
public PropertyBlock(
bool isPublic,
bool isDefault,
NameToken name,
PropertyType propType,
IEnumerable <Parameter> parameters,
IEnumerable <ICodeBlock> statements)
: base(isPublic, isDefault, (propType == PropertyType.Get), name, parameters, statements)
{
bool isValid = false;
foreach (object value in Enum.GetValues(typeof(PropertyType)))
{
if (value.Equals(propType))
{
isValid = true;
break;
}
}
if (!isValid)
{
throw new ArgumentException("Invalid type value specified [" + propType.ToString() + "]");
}
PropType = propType;
}
private void LoadFontDictionary(DictionaryToken fontDictionary, bool isLenientParsing)
{
foreach (var pair in fontDictionary.Data)
{
if (!(pair.Value is IndirectReferenceToken objectKey))
{
if (isLenientParsing)
{
continue;
}
throw new InvalidOperationException($"The font with name {pair.Key} did not link to an object key. Value was: {pair.Value}.");
}
var reference = objectKey.Data;
currentResourceState[NameToken.Create(pair.Key)] = reference;
if (loadedFonts.ContainsKey(reference))
{
continue;
}
var fontObject = DirectObjectFinder.Get <DictionaryToken>(objectKey, scanner);
if (fontObject == null)
{
throw new InvalidOperationException($"Could not retrieve the font with name: {pair.Key} which should have been object {objectKey}");
}
loadedFonts[reference] = fontFactory.Get(fontObject, isLenientParsing);
}
}
public Type1FontSimple(NameToken name, int firstChar, int lastChar, double[] widths, FontDescriptor fontDescriptor, Encoding encoding,
CMap toUnicodeCMap,
Union <Type1Font, CompactFontFormatFontCollection> fontProgram)
{
this.firstChar = firstChar;
this.lastChar = lastChar;
this.widths = widths;
this.fontDescriptor = fontDescriptor;
this.encoding = encoding;
this.fontProgram = fontProgram;
this.toUnicodeCMap = new ToUnicodeCMap(toUnicodeCMap);
var matrix = DefaultTransformationMatrix;
if (fontProgram != null)
{
if (fontProgram.TryGetFirst(out var t1Font))
{
matrix = t1Font.FontMatrix;
}
else if (fontProgram.TryGetSecond(out var cffFont))
{
matrix = cffFont.GetFirstTransformationMatrix();
}
}
fontMatrix = matrix;
Name = name;
Details = fontDescriptor?.ToDetails(name?.Data)
?? FontDetails.GetDefault(name?.Data);
}
public Type0Font(NameToken baseFont, ICidFont cidFont, CMap cmap, CMap toUnicodeCMap)
{
BaseFont = baseFont ?? throw new ArgumentNullException(nameof(baseFont));
CidFont = cidFont ?? throw new ArgumentNullException(nameof(cidFont));
CMap = cmap ?? throw new ArgumentNullException(nameof(cmap));
ToUnicode = new ToUnicodeCMap(toUnicodeCMap);
}
public override Expression VisitTerminal(ITerminalNode node)
{
base.VisitTerminal(node);
NameToken token = new NameToken(node.GetText());
return(Expression.Constant(token));
}
public void AttributeParsing_Namespaces()
{
var target = ParserAccessor.CreateParser("ns:name=foo");
target.AttributeFound +=
delegate(object sender, HtmlParserAttributeEventArgs args) {
Assert.True(args.AttributeToken is AttributeToken);
AttributeToken at = args.AttributeToken;
Assert.True(at.HasName());
Assert.Equal(0, at.NameToken.Start);
Assert.Equal(7, at.NameToken.End);
Assert.True(at.HasValue());
Assert.Equal(8, at.ValueToken.Start);
Assert.Equal(11, at.ValueToken.End);
NameToken nameToken = at.NameToken as NameToken;
Assert.True(nameToken.HasQualifiedName());
Assert.True(nameToken.NameRange.Length > 0);
Assert.Equal(3, nameToken.NameRange.Start);
Assert.Equal(7, nameToken.NameRange.End);
Assert.True(nameToken.PrefixRange.Length > 0);
Assert.Equal(0, nameToken.PrefixRange.Start);
Assert.Equal(2, nameToken.PrefixRange.End);
};
target.OnAttributeState();
}
public void AttributeParsing_NamespacesMissingNameAndPrefix()
{
var target = ParserAccessor.CreateParser(":=foo");
target.AttributeFound +=
delegate(object sender, HtmlParserAttributeEventArgs args) {
Assert.True(args.AttributeToken is AttributeToken);
AttributeToken at = args.AttributeToken;
Assert.False(at.HasName());
Assert.True(at.HasValue());
Assert.Equal(2, at.ValueToken.Start);
Assert.Equal(3, at.ValueToken.Length);
NameToken nameToken = at.NameToken as NameToken;
Assert.Equal(1, nameToken.ColonRange.Length);
Assert.False(nameToken.HasName());
Assert.Equal(0, nameToken.NameRange.Length);
Assert.False(nameToken.HasPrefix());
Assert.Equal(0, nameToken.PrefixRange.Length);
};
target.OnAttributeState();
}
public bool TryTokenize(byte currentByte, IInputBytes inputBytes, out IToken token)
{
token = null;
if (currentByte != '{')
{
return(false);
}
var builder = new StringBuilder();
while (inputBytes.MoveNext())
{
if (inputBytes.CurrentByte == '}')
{
break;
}
builder.Append((char)inputBytes.CurrentByte);
}
var parts = builder.ToString().Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
var tokens = new List <IToken>();
foreach (var part in parts)
{
if (char.IsNumber(part[0]) || part[0] == '-')
{
if (decimal.TryParse(part, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var value))
{
tokens.Add(new NumericToken(value));
}
else
{
tokens.Add(OperatorToken.Create(part));
}
continue;
}
if (part[0] == '/')
{
tokens.Add(NameToken.Create(part.Substring(1)));
continue;
}
if (part[0] == '(' && part[part.Length - 1] == ')')
{
tokens.Add(new StringToken(part));
continue;
}
tokens.Add(OperatorToken.Create(part));
}
token = new ArrayToken(tokens);
return(true);
}
internal void OnEndTagState()
{
Debug.Assert(_cs.CurrentChar == '<' && _cs.NextChar == '/');
int start = _cs.Position;
_cs.Advance(2);
// element name may be missing
if (_cs.CurrentChar == '<')
{
return;
}
NameToken nameToken = _tokenizer.GetNameToken();
if (nameToken == null || nameToken.Length == 0)
{
return;
}
if (EndTagOpen != null)
{
EndTagOpen(this, new HtmlParserOpenTagEventArgs(start, nameToken));
}
while (!_cs.IsEndOfStream())
{
_tokenizer.SkipWhitespace();
if (_cs.CurrentChar == '>')
{
var range = new TextRange(_cs.Position);
if (EndTagClose != null)
{
EndTagClose(this, new HtmlParserCloseTagEventArgs(range, true, false));
}
_cs.MoveToNextChar();
return;
}
if (_cs.CurrentChar == '<')
{
// Untermimated end tag (sequence may be '</<', '</{ws}>', '</>', '</name <'
// '</name attrib="value" <' and so on. Close tag at the previous position.
if (EndTagClose != null)
{
EndTagClose(this, new HtmlParserCloseTagEventArgs(new TextRange(_cs.Position - 1), false, false));
}
return;
}
// attributes are not allowed in end tags so skip over any extra characters until > or <
_cs.MoveToNextChar();
}
}
public static FontStretch ConvertToFontStretch(this NameToken name)
{
switch (name.Data)
{
case "UltraCondensed":
return(FontStretch.UltraCondensed);
case "ExtraCondensed":
return(FontStretch.ExtraCondensed);
case "Condensed":
return(FontStretch.Condensed);
case "Normal":
return(FontStretch.Normal);
case "SemiExpanded":
return(FontStretch.SemiExpanded);
case "Expanded":
return(FontStretch.Expanded);
case "ExtraExpanded":
return(FontStretch.ExtraExpanded);
case "UltraExpanded":
return(FontStretch.UltraExpanded);
default:
return(FontStretch.Unknown);
}
}
private static Dictionary <NameToken, IToken> ConvertToDictionary(List <IToken> tokens)
{
var result = new Dictionary <NameToken, IToken>();
NameToken key = null;
for (var i = 0; i < tokens.Count; i++)
{
var token = tokens[i];
if (key == null)
{
if (token is NameToken name)
{
key = name;
continue;
}
throw new PdfDocumentFormatException($"Expected name as dictionary key, instead got: " + token);
}
// Combine indirect references, e.g. 12 0 R
if (token is NumericToken num && PeekNext(tokens, i) is NumericToken gen)
{
var r = PeekNext(tokens, i + 1);
if (r == OperatorToken.R)
{
result[key] = new IndirectReferenceToken(new IndirectReference(num.Long, gen.Int));
i = i + 2;
}
}
public void NameToken_QualifiedNameTest()
{
var token = NameToken.Create(0, 5, 5, 6, 4);
Assert.Equal(0, token.QualifiedName.Start);
Assert.Equal(10, token.QualifiedName.End);
}
public void LoadResourceDictionary(DictionaryToken resourceDictionary, bool isLenientParsing)
{
if (resourceDictionary.TryGet(NameToken.Font, out var fontBase))
{
var fontDictionary = DirectObjectFinder.Get <DictionaryToken>(fontBase, scanner);
LoadFontDictionary(fontDictionary, isLenientParsing);
}
if (resourceDictionary.TryGet(NameToken.Xobject, out var xobjectBase))
{
var xobjectDictionary = DirectObjectFinder.Get <DictionaryToken>(xobjectBase, scanner);
foreach (var pair in xobjectDictionary.Data)
{
if (!(pair.Value is IndirectReferenceToken reference))
{
throw new InvalidOperationException($"Expected the XObject dictionary value for key /{pair.Key} to be an indirect reference, instead got: {pair.Value}.");
}
currentResourceState[NameToken.Create(pair.Key)] = reference.Data;
}
}
if (resourceDictionary.TryGet(NameToken.ExtGState, scanner, out DictionaryToken extGStateDictionaryToken))
{
foreach (var pair in extGStateDictionaryToken.Data)
{
var name = NameToken.Create(pair.Key);
var state = DirectObjectFinder.Get <DictionaryToken>(pair.Value, scanner);
extendedGraphicsStates[name] = state;
}
}
}
private string SafeKeyAccess(DictionaryToken dictionary, NameToken keyName)
{
if (!dictionary.TryGet(keyName, out var token))
{
return(string.Empty);
}
if (token is StringToken str)
{
return(str.Data);
}
if (token is HexToken hex)
{
return(hex.Data);
}
if (token is IndirectReferenceToken obj)
{
if (DirectObjectFinder.TryGet(obj, pdfScanner, out StringToken stringToken))
{
return(stringToken.Data);
}
if (DirectObjectFinder.TryGet(obj, pdfScanner, out HexToken hexToken))
{
return(hexToken.Data);
}
throw new PdfDocumentFormatException($"Could not get key for name: {keyName} in {dictionary}.");
}
return(string.Empty);
}
public void CanReadDocumentInformation()
{
var path = IntegrationHelpers.GetSpecificTestDocumentPath("custom-properties.pdf");
using (var document = PdfDocument.Open(path))
{
var information = document.Information;
Assert.Equal("Writer", information.Creator);
Assert.Equal("MoreKeywords", information.Keywords);
Assert.Equal("LibreOffice 6.1", information.Producer);
Assert.Equal("TestSubject", information.Subject);
Assert.Equal("TestTitle", information.Title);
var infoDictionary = information.DocumentInformationDictionary;
var nameToken = NameToken.Create("CustomProperty1");
Assert.True(infoDictionary.TryGet(nameToken, out var valueToken), "first custom property must be present");
Assert.IsType <StringToken>(valueToken);
Assert.Equal("Property Value", ((StringToken)valueToken).Data);
nameToken = NameToken.Create("CustomProperty2");
Assert.True(infoDictionary.TryGet(nameToken, out var valueToken2), "second custom property must be present");
Assert.IsType <StringToken>(valueToken2);
Assert.Equal("Another Property Value", ((StringToken)valueToken2).Data);
}
}
private IndirectReferenceToken CopyPageNode(PageTreeNode pageNode, IndirectReferenceToken parentPagesObject, IPdfTokenScanner tokenScanner)
{
Debug.Assert(pageNode.IsPage);
var pageDictionary = new Dictionary <NameToken, IToken>
{
{ NameToken.Parent, parentPagesObject },
};
foreach (var setPair in pageNode.NodeDictionary.Data)
{
var name = setPair.Key;
var token = setPair.Value;
if (name == NameToken.Parent)
{
// Skip Parent token, since we have to reassign it
continue;
}
pageDictionary.Add(NameToken.Create(name), CopyToken(token, tokenScanner));
}
return(context.WriteToken(new DictionaryToken(pageDictionary)));
}
public void SetNamedGraphicsState(NameToken stateName)
{
var currentGraphicsState = GetCurrentState();
var state = resourceStore.GetExtendedGraphicsStateDictionary(stateName);
if (state.TryGet(NameToken.Lw, pdfScanner, out NumericToken lwToken))
{
currentGraphicsState.LineWidth = lwToken.Data;
}
if (state.TryGet(NameToken.Lc, pdfScanner, out NumericToken lcToken))
{
currentGraphicsState.CapStyle = (LineCapStyle)lcToken.Int;
}
if (state.TryGet(NameToken.Lj, pdfScanner, out NumericToken ljToken))
{
currentGraphicsState.JoinStyle = (LineJoinStyle)ljToken.Int;
}
if (state.TryGet(NameToken.Font, pdfScanner, out ArrayToken fontArray) && fontArray.Length == 2 &&
fontArray.Data[0] is IndirectReferenceToken fontReference && fontArray.Data[1] is NumericToken sizeToken)
{
currentGraphicsState.FontState.FromExtendedGraphicsState = true;
currentGraphicsState.FontState.FontSize = (double)sizeToken.Data;
activeExtendedGraphicsStateFont = resourceStore.GetFontDirectly(fontReference);
}
}
public static bool TryGetNamedEncoding(NameToken name, out Encoding encoding)
{
encoding = null;
if (name == null)
{
return(false);
}
if (name.Equals(NameToken.StandardEncoding))
{
encoding = StandardEncoding.Instance;
return(true);
}
if (name.Equals(NameToken.WinAnsiEncoding))
{
encoding = WinAnsiEncoding.Instance;
return(true);
}
if (name.Equals(NameToken.MacExpertEncoding))
{
encoding = MacExpertEncoding.Instance;
return(true);
}
if (name.Equals(NameToken.MacRomanEncoding))
{
encoding = MacRomanEncoding.Instance;
return(true);
}
return(false);
}
internal ArtifactMarkedContentElement(int markedContentIdentifier, NameToken tag, DictionaryToken properties,
string language,
string actualText,
string alternateDescription,
string expandedForm,
ArtifactType artifactType,
string subType,
string attributeOwners,
PdfRectangle?boundingBox,
IReadOnlyList <NameToken> attached,
IReadOnlyList <MarkedContentElement> children,
IReadOnlyList <Letter> letters,
IReadOnlyList <PdfPath> paths,
IReadOnlyList <IPdfImage> images,
int index)
: base(markedContentIdentifier, tag, properties, language,
actualText,
alternateDescription,
expandedForm,
true,
children,
letters,
paths,
images,
index)
{
Type = artifactType;
SubType = subType;
AttributeOwners = attributeOwners;
BoundingBox = boundingBox;
Attached = attached ?? EmptyArray <NameToken> .Instance;
}
public void SetFontAndSize(NameToken font, double size)
{
var currentState = GetCurrentState();
currentState.FontState.FontSize = size;
currentState.FontState.FontName = font;
}
public StreamToken GetXObject(NameToken name)
{
var reference = currentResourceState[name];
var stream = DirectObjectFinder.Get <StreamToken>(new IndirectReferenceToken(reference), scanner);
return(stream);
}
public IFont GetFont(NameToken name)
{
var reference = currentResourceState[name];
loadedFonts.TryGetValue(reference, out var font);
return(font);
}
public void AppendName([NotNull] T4CSharpCodeGenerationResult result)
{
if (CSharpLexer.IsKeyword(NameToken.GetText()))
{
result.Append("@");
}
result.AppendMapped(NameToken);
}
public Type1Standard14Font(FontMetrics standardFontMetrics)
{
this.standardFontMetrics = standardFontMetrics ?? throw new ArgumentNullException(nameof(standardFontMetrics));
encoding = new AdobeFontMetricsEncoding(standardFontMetrics);
Name = NameToken.Create(standardFontMetrics.FontName);
IsVertical = false;
}
public NamedExpression(string name, Expression expression, object idAnnotation)
{
this.Name = name;
if (idAnnotation != null)
{
NameToken.AddAnnotation(idAnnotation);
}
this.Expression = expression;
}
/// <summary>
/// Create a new <see cref="SeparationColorSpaceDetails"/>.
/// </summary>
public SeparationColorSpaceDetails(NameToken name,
ColorSpaceDetails alternateColorSpaceDetails,
Union <DictionaryToken, StreamToken> tintFunction)
: base(ColorSpace.Separation)
{
Name = name;
AlternateColorSpaceDetails = alternateColorSpaceDetails;
TintFunction = tintFunction;
}
MarkupExtensionKind GetMarkupExtensionKind(NameToken name) {
// This code assumes default namespaces are used
if (name.HasNamespace) {
if (owner.Equals(name.Namespace.Span, "x")) {
if (owner.Equals(name.Name.Span, "Type"))
return MarkupExtensionKind.TypeParam;
if (owner.Equals(name.Name.Span, "Static"))
return MarkupExtensionKind.TypeParam;
}
}
else {
if (owner.Equals(name.Name.Span, "Binding"))
return MarkupExtensionKind.PropertyParam;
if (owner.Equals(name.Name.Span, "TemplateBinding"))
return MarkupExtensionKind.PropertyParam;
if (owner.Equals(name.Name.Span, "DynamicResource"))
return MarkupExtensionKind.ResourceParam;
if (owner.Equals(name.Name.Span, "StaticResource"))
return MarkupExtensionKind.ResourceParam;
if (owner.Equals(name.Name.Span, "RelativeSource"))
return MarkupExtensionKind.RelativeSource;
}
return MarkupExtensionKind.Unknown;
}
void SaveReference(NameToken name, XmlNameReferenceKind refKind) => owner.SaveReference(name.HasNamespace, name.Namespace.Span, name.Name.Span, refKind, findDefsOnly: false);
