public virtual void DeepCopyTest()
{
PolygonSvgNodeRenderer expected = new PolygonSvgNodeRenderer();
expected.SetAttribute(SvgConstants.Attributes.FILL, "blue");
ISvgNodeRenderer actual = expected.CreateDeepCopy();
NUnit.Framework.Assert.AreEqual(expected, actual);
}
/// <summary>Recursive visit of the object tree, depth-first, processing the visited node and calling visit on its children.
/// </summary>
/// <remarks>
/// Recursive visit of the object tree, depth-first, processing the visited node and calling visit on its children.
/// Visit responsibilities for element nodes:
/// - Assign styles(CSS and attributes) to element
/// - Create Renderer based on element
/// - push and pop renderer to stack
/// Visit responsibilities for text nodes
/// - add text to parent object
/// </remarks>
/// <param name="node">INode to visit</param>
private void Visit(INode node)
{
if (node is IElementNode)
{
IElementNode element = (IElementNode)node;
if (!rendererFactory.IsTagIgnored(element))
{
ISvgNodeRenderer renderer = CreateRenderer(element, processorState.Top());
if (renderer != null)
{
IDictionary <String, String> styles = cssResolver.ResolveStyles(node, cssContext);
element.SetStyles(styles);
//For inheritance
renderer.SetAttributesAndStyles(styles);
//For drawing operations
String attribute = renderer.GetAttribute(SvgConstants.Attributes.ID);
if (attribute != null)
{
namedObjects.Put(attribute, renderer);
}
// don't add the NoDrawOperationSvgNodeRenderer or its subtree to the ISvgNodeRenderer tree
if (!(renderer is NoDrawOperationSvgNodeRenderer))
{
if (processorState.Top() is IBranchSvgNodeRenderer)
{
((IBranchSvgNodeRenderer)processorState.Top()).AddChild(renderer);
}
else
{
if (processorState.Top() is TextSvgBranchRenderer && renderer is ISvgTextNodeRenderer)
{
//Text branch node renderers only accept ISvgTextNodeRenderers
((TextSvgBranchRenderer)processorState.Top()).AddChild((ISvgTextNodeRenderer)renderer);
}
}
}
processorState.Push(renderer);
}
foreach (INode childNode in element.ChildNodes())
{
Visit(childNode);
}
if (renderer != null)
{
processorState.Pop();
}
}
}
else
{
if (ProcessAsText(node))
{
ProcessText((ITextNode)node);
}
}
}
public virtual void CustomMapperTest()
{
fact = new DefaultSvgNodeRendererFactory(new DefaultSvgNodeRendererFactoryTest.LocalTestMapper());
iText.StyledXmlParser.Jsoup.Nodes.Element element = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("test"), "");
IElementNode tag = new JsoupElementNode(element);
ISvgNodeRenderer rend = fact.CreateSvgNodeRendererForTag(tag, null);
NUnit.Framework.Assert.IsTrue(rend is DummyProcessableSvgNodeRenderer);
}
public virtual void ProcessorStateTestPeek()
{
ProcessorState testProcessorState = new ProcessorState();
ISvgNodeRenderer renderer = new DummySvgNodeRenderer("test");
testProcessorState.Push(renderer);
ISvgNodeRenderer viewed = testProcessorState.Top();
NUnit.Framework.Assert.IsTrue(viewed.ToString().Equals("test") && !testProcessorState.Empty());
}
/// <summary>
/// Make a deep copy of the styles and attributes of this renderer
/// Helper method for deep copying logic
/// </summary>
/// <param name="deepCopy">renderer to insert the deep copied attributes into</param>
protected internal virtual void DeepCopyAttributesAndStyles(ISvgNodeRenderer deepCopy)
{
IDictionary <String, String> stylesDeepCopy = new Dictionary <String, String>();
if (this.attributesAndStyles != null)
{
stylesDeepCopy.AddAll(this.attributesAndStyles);
deepCopy.SetAttributesAndStyles(stylesDeepCopy);
}
}
public virtual void DeepCopyTest()
{
SvgTagSvgNodeRenderer expected = new SvgTagSvgNodeRenderer();
expected.SetAttribute(SvgConstants.Attributes.FILL, "blue");
expected.AddChild(new CircleSvgNodeRenderer());
ISvgNodeRenderer actual = expected.CreateDeepCopy();
NUnit.Framework.Assert.AreEqual(expected, actual);
}
public virtual void DeepCopyTest()
{
//Deep copy of tree with nested svg and group and set attributes
UseSvgNodeRenderer nestedUse = new UseSvgNodeRenderer();
nestedUse.SetAttribute(SvgConstants.Attributes.HREF, "#c1");
GroupSvgNodeRenderer nestedGroup = new GroupSvgNodeRenderer();
nestedGroup.SetAttribute(SvgConstants.Attributes.FILL, "blue");
nestedGroup.AddChild(nestedUse);
CircleSvgNodeRenderer nestedCircle = new CircleSvgNodeRenderer();
nestedCircle.SetAttribute(SvgConstants.Attributes.R, "100");
SvgTagSvgNodeRenderer nestedSvg = new SvgTagSvgNodeRenderer();
nestedSvg.SetAttribute(SvgConstants.Attributes.X, "200");
nestedSvg.SetAttribute(SvgConstants.Attributes.Y, "200");
nestedSvg.SetAttribute(SvgConstants.Attributes.XMLNS, SvgConstants.Values.SVGNAMESPACEURL);
nestedSvg.SetAttribute(SvgConstants.Attributes.VERSION, SvgConstants.Values.VERSION1_1);
nestedSvg.AddChild(nestedCircle);
nestedSvg.AddChild(nestedGroup);
RectangleSvgNodeRenderer nestedRectangle = new RectangleSvgNodeRenderer();
nestedRectangle.SetAttribute(SvgConstants.Attributes.WIDTH, "100");
nestedRectangle.SetAttribute(SvgConstants.Attributes.HEIGHT, "50");
GroupSvgNodeRenderer topGroup = new GroupSvgNodeRenderer();
topGroup.SetAttribute(SvgConstants.Attributes.FILL, "red");
topGroup.AddChild(nestedRectangle);
CircleSvgNodeRenderer topCircle = new CircleSvgNodeRenderer();
topCircle.SetAttribute(SvgConstants.Attributes.R, "80");
topCircle.SetAttribute(SvgConstants.Attributes.X, "100");
topCircle.SetAttribute(SvgConstants.Attributes.Y, "100");
topCircle.SetAttribute(SvgConstants.Attributes.STROKE, "red");
topCircle.SetAttribute(SvgConstants.Attributes.FILL, "green");
SvgTagSvgNodeRenderer topSvg = new SvgTagSvgNodeRenderer();
topSvg.SetAttribute(SvgConstants.Attributes.WIDTH, "800");
topSvg.SetAttribute(SvgConstants.Attributes.HEIGHT, "800");
topSvg.SetAttribute(SvgConstants.Attributes.XMLNS, SvgConstants.Values.SVGNAMESPACEURL);
topSvg.SetAttribute(SvgConstants.Attributes.VERSION, SvgConstants.Values.VERSION1_1);
topSvg.AddChild(topCircle);
topSvg.AddChild(topGroup);
EllipseSvgNodeRenderer ellipse = new EllipseSvgNodeRenderer();
ellipse.SetAttribute(SvgConstants.Attributes.CX, "10");
ellipse.SetAttribute(SvgConstants.Attributes.CY, "20");
ellipse.SetAttribute(SvgConstants.Attributes.RX, "30");
ellipse.SetAttribute(SvgConstants.Attributes.RX, "40");
topSvg.AddChild(ellipse);
ISvgNodeRenderer copy = topSvg.CreateDeepCopy();
NUnit.Framework.Assert.AreEqual(topSvg, copy);
}
public virtual void DeepCopyTest()
{
SvgTagSvgNodeRenderer subTree = new SvgTagSvgNodeRenderer();
subTree.AddChild(new CircleSvgNodeRenderer());
PdfRootSvgNodeRenderer expected = new PdfRootSvgNodeRenderer(subTree);
ISvgNodeRenderer actual = expected.CreateDeepCopy();
expected.Equals(actual);
NUnit.Framework.Assert.AreEqual(expected, actual);
}
private ISvgNodeRenderer GetSvgRootElement(ISvgNodeRenderer element)
{
if (element is SvgTagSvgNodeRenderer && element.GetParent() is PdfRootSvgNodeRenderer)
{
return(element);
}
if (element.GetParent() != null)
{
return(GetSvgRootElement(element.GetParent()));
}
return(null);
}
// TODO (DEVSIX-3596) Add support of 'lh' 'ch' units and viewport-relative units
private float ParseFontRelativeOrAbsoluteLengthOnMarker(String length)
{
float value = 0f;
if (CssUtils.IsMetricValue(length) || CssUtils.IsNumericValue(length))
{
value = CssUtils.ParseAbsoluteLength(length);
}
else
{
if (CssUtils.IsFontRelativeValue(length))
{
// Defaut font-size is medium
value = CssUtils.ParseRelativeValue(length, CssUtils.ParseAbsoluteFontSize(CommonCssConstants.MEDIUM));
// Different browsers process font-relative units for markers differently.
// We do it according to the css specification.
if (CssUtils.IsRemValue(length))
{
ISvgNodeRenderer rootElement = GetSvgRootElement(GetParent());
if (rootElement != null && rootElement.GetAttribute(CommonCssConstants.FONT_SIZE) != null)
{
value = CssUtils.ParseRelativeValue(length, CssUtils.ParseAbsoluteFontSize(rootElement.GetAttribute(CommonCssConstants
.FONT_SIZE)));
}
}
else
{
if (CssUtils.IsEmValue(length))
{
ISvgNodeRenderer parentElement = this.GetParent();
if (parentElement != null && parentElement.GetAttribute(CommonCssConstants.FONT_SIZE) != null)
{
value = CssUtils.ParseRelativeValue(length, CssUtils.ParseAbsoluteFontSize(parentElement.GetAttribute(CommonCssConstants
.FONT_SIZE)));
}
}
else
{
if (CssUtils.IsExValue(length))
{
if (this.GetAttribute(CommonCssConstants.FONT_SIZE) != null)
{
value = CssUtils.ParseRelativeValue(length, CssUtils.ParseAbsoluteFontSize(this.GetAttribute(CommonCssConstants
.FONT_SIZE)));
}
}
}
}
}
}
return(value);
}
public virtual void ProcessorStateTestPushSameElementTwice()
{
ProcessorState testProcessorState = new ProcessorState();
ISvgNodeRenderer rendererOne = new DummySvgNodeRenderer("test01");
testProcessorState.Push(rendererOne);
testProcessorState.Push(rendererOne);
ISvgNodeRenderer popped = testProcessorState.Pop();
bool result = popped.ToString().Equals("test01");
result = result && testProcessorState.Top().ToString().Equals("test01");
NUnit.Framework.Assert.IsTrue(result);
}
public virtual void BasicProcessedRendererTest()
{
iText.StyledXmlParser.Jsoup.Nodes.Element element = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("processable"), "");
IElementNode tag = new JsoupElementNode(element);
ISvgNodeRenderer renderer = fact.CreateSvgNodeRendererForTag(tag, null);
NUnit.Framework.Assert.IsTrue(renderer is DummyProcessableSvgNodeRenderer);
renderer.Draw(new SvgDrawContext(null, null));
DummyProcessableSvgNodeRenderer processed = (DummyProcessableSvgNodeRenderer)renderer;
NUnit.Framework.Assert.IsTrue(processed.IsProcessed());
}
/// <summary>Process the text contained in the text-node</summary>
/// <param name="textNode">node containing text to process</param>
private void ProcessText(ITextNode textNode)
{
ISvgNodeRenderer parentRenderer = this.processorState.Top();
if (parentRenderer is TextSvgBranchRenderer) {
String wholeText = textNode.WholeText();
if (!"".Equals(wholeText) && !SvgTextUtil.IsOnlyWhiteSpace(wholeText)) {
TextLeafSvgNodeRenderer textLeaf = new TextLeafSvgNodeRenderer();
textLeaf.SetParent(parentRenderer);
textLeaf.SetAttribute(SvgConstants.Attributes.TEXT_CONTENT, wholeText);
((TextSvgBranchRenderer)parentRenderer).AddChild(textLeaf);
}
}
}
/// <summary>Apply style and attribute inheritance to the tree formed by the root and the subTree</summary>
/// <param name="root">Renderer to consider as the root of the substree</param>
/// <param name="subTree">
/// tree of
/// <see cref="iText.Svg.Renderers.ISvgNodeRenderer"/>
/// s
/// </param>
public virtual void ApplyInheritanceToSubTree(ISvgNodeRenderer root, ISvgNodeRenderer subTree)
{
//Merge inherited style declarations from parent into child
ApplyStyles(root, subTree);
//If subtree, iterate over tree
if (subTree is AbstractBranchSvgNodeRenderer)
{
AbstractBranchSvgNodeRenderer subTreeAsBranch = (AbstractBranchSvgNodeRenderer)subTree;
foreach (ISvgNodeRenderer child in subTreeAsBranch.GetChildren())
{
ApplyInheritanceToSubTree(subTreeAsBranch, child);
}
}
}
public virtual void HierarchyTagTest()
{
iText.StyledXmlParser.Jsoup.Nodes.Element parentEl = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("dummy"), "");
IElementNode parentTag = new JsoupElementNode(parentEl);
iText.StyledXmlParser.Jsoup.Nodes.Element childEl = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("dummy"), "");
IElementNode childTag = new JsoupElementNode(childEl);
ISvgNodeRenderer parentRenderer = fact.CreateSvgNodeRendererForTag(parentTag, null);
ISvgNodeRenderer childRenderer = fact.CreateSvgNodeRendererForTag(childTag, parentRenderer);
NUnit.Framework.Assert.AreEqual(parentRenderer, childRenderer.GetParent());
}
public virtual void XLinkAttributeResolveNonEmptyBaseUrlTest()
{
INode root = CreateSvgContainingImage();
String baseUrl = iText.Test.TestUtil.GetParentProjectDirectory(NUnit.Framework.TestContext.CurrentContext.
TestDirectory) + "/resources/itext/svg/processors/impl/DefaultSvgProcessorIntegrationTest";
ISvgConverterProperties props = new SvgConverterProperties().SetBaseUri(baseUrl);
SvgTagSvgNodeRenderer rootActual = (SvgTagSvgNodeRenderer)Processor().Process(root, props).GetRootRenderer
();
String fileName = baseUrl + "/img.png";
String expectedURL = UrlUtil.ToNormalizedURI(fileName).ToString();
ISvgNodeRenderer imageRendered = rootActual.GetChildren()[0];
String url = imageRendered.GetAttribute(SvgConstants.Attributes.XLINK_HREF);
NUnit.Framework.Assert.AreEqual(expectedURL, url);
}
public virtual void ProcessWithNullPropertiesTest()
{
iText.StyledXmlParser.Jsoup.Nodes.Element jsoupSVGRoot = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("svg"), "");
INode root = new JsoupElementNode(jsoupSVGRoot);
DefaultSvgProcessor processor = new DefaultSvgProcessor();
SvgConverterProperties convProps = new SvgConverterProperties();
convProps.SetRendererFactory(null);
convProps.SetCharset(null);
ISvgNodeRenderer rootRenderer = processor.Process(root, convProps).GetRootRenderer();
NUnit.Framework.Assert.IsTrue(rootRenderer is SvgTagSvgNodeRenderer);
NUnit.Framework.Assert.AreEqual(0, ((SvgTagSvgNodeRenderer)rootRenderer).GetChildren().Count);
}
public virtual void XLinkAttributeBaseDirDoesNotExistTest()
{
INode root = CreateSvgContainingImage();
String resolvedBaseUrl = "/i7j/itextcore";
String baseUrl = resolvedBaseUrl + "/wrongDirName";
ISvgConverterProperties props = new SvgConverterProperties().SetBaseUri(baseUrl);
SvgTagSvgNodeRenderer rootActual = (SvgTagSvgNodeRenderer)Processor().Process(root, props).GetRootRenderer
();
String fileName = resolvedBaseUrl + "/img.png";
String expectedURL = UrlUtil.ToNormalizedURI(fileName).ToString();
ISvgNodeRenderer imageRendered = rootActual.GetChildren()[0];
String url = imageRendered.GetAttribute(SvgConstants.Attributes.XLINK_HREF);
NUnit.Framework.Assert.AreEqual(expectedURL, url);
}
/// <summary>Adds a named object to the draw context.</summary>
/// <remarks>Adds a named object to the draw context. These objects can then be referenced from a different tag.
/// </remarks>
/// <param name="name">name of the object</param>
/// <param name="namedObject">object to be referenced</param>
public virtual void AddNamedObject(String name, ISvgNodeRenderer namedObject)
{
if (namedObject == null)
{
throw new SvgProcessingException(SvgLogMessageConstant.NAMED_OBJECT_NULL);
}
if (name == null || String.IsNullOrEmpty(name))
{
throw new SvgProcessingException(SvgLogMessageConstant.NAMED_OBJECT_NAME_NULL_OR_EMPTY);
}
if (!this.namedObjects.ContainsKey(name))
{
this.namedObjects.Put(name, namedObject);
}
}
public virtual void ProcessorStateTestMultiplePushesPopAndPeek()
{
ProcessorState testProcessorState = new ProcessorState();
ISvgNodeRenderer rendererOne = new DummySvgNodeRenderer("test01");
testProcessorState.Push(rendererOne);
ISvgNodeRenderer rendererTwo = new DummySvgNodeRenderer("test02");
testProcessorState.Push(rendererTwo);
ISvgNodeRenderer popped = testProcessorState.Pop();
bool result = popped.ToString().Equals("test02");
result = result && testProcessorState.Top().ToString().Equals("test01");
NUnit.Framework.Assert.IsTrue(result);
}
/// <summary>Start the depth-first traversal of the INode tree, pushing the results on the stack</summary>
/// <param name="startingNode">node to start on</param>
internal virtual void ExecuteDepthFirstTraversal(INode startingNode)
{
//Create and push rootNode
if (startingNode is IElementNode && !rendererFactory.IsTagIgnored((IElementNode)startingNode)) {
IElementNode rootElementNode = (IElementNode)startingNode;
ISvgNodeRenderer startingRenderer = rendererFactory.CreateSvgNodeRendererForTag(rootElementNode, null);
if (startingRenderer != null) {
IDictionary<String, String> attributesAndStyles = cssResolver.ResolveStyles(startingNode, cssContext);
rootElementNode.SetStyles(attributesAndStyles);
startingRenderer.SetAttributesAndStyles(attributesAndStyles);
processorState.Push(startingRenderer);
foreach (INode rootChild in startingNode.ChildNodes()) {
Visit(rootChild);
}
}
}
}
public virtual void NoBoundingBoxOnXObjectTest()
{
NUnit.Framework.Assert.That(() => {
PdfDocument document = new PdfDocument(new PdfWriter(new MemoryStream(), new WriterProperties().SetCompressionLevel
(0)));
document.AddNewPage();
ISvgNodeRenderer processed = SvgConverter.Process(SvgConverter.Parse("<svg />")).GetRootRenderer();
PdfRootSvgNodeRenderer root = new PdfRootSvgNodeRenderer(processed);
PdfFormXObject pdfForm = new PdfFormXObject(new PdfStream());
PdfCanvas canvas = new PdfCanvas(pdfForm, document);
SvgDrawContext context = new SvgDrawContext(null, null);
context.PushCanvas(canvas);
root.Draw(context);
}
, NUnit.Framework.Throws.InstanceOf <SvgProcessingException>().With.Message.EqualTo(SvgLogMessageConstant.ROOT_SVG_NO_BBOX))
;
}
private bool DrawInClipPath(SvgDrawContext context)
{
if (attributesAndStyles.ContainsKey(SvgConstants.Attributes.CLIP_PATH))
{
String clipPathName = attributesAndStyles.Get(SvgConstants.Attributes.CLIP_PATH);
ISvgNodeRenderer template = context.GetNamedObject(NormalizeLocalUrlName(clipPathName));
//Clone template to avoid muddying the state
if (template is ClipPathSvgNodeRenderer)
{
ClipPathSvgNodeRenderer clipPath = (ClipPathSvgNodeRenderer)template.CreateDeepCopy();
clipPath.SetClippedRenderer(this);
clipPath.Draw(context);
return(!clipPath.GetChildren().IsEmpty());
}
}
return(false);
}
/// <summary>Process the text contained in the text-node</summary>
/// <param name="textNode">node containing text to process</param>
private void ProcessText(ITextNode textNode)
{
ISvgNodeRenderer parentRenderer = this.processorState.Top();
if (parentRenderer is TextSvgNodeRenderer)
{
// when svg is parsed by jsoup it leaves all whitespace in text element as is. Meaning that
// tab/space indented xml files will retain their tabs and spaces.
// The following regex replaces all whitespace with a single space.
//TODO(RND-906) evaluate regex and trim methods
String trimmedText = iText.IO.Util.StringUtil.ReplaceAll(textNode.WholeText(), "\\s+", " ");
//Trim leading whitespace
trimmedText = SvgTextUtil.TrimLeadingWhitespace(trimmedText);
//Trim trailing whitespace
trimmedText = SvgTextUtil.TrimTrailingWhitespace(trimmedText);
parentRenderer.SetAttribute(SvgConstants.Attributes.TEXT_CONTENT, trimmedText);
}
}
private TransparentColor GetColorFromAttributeValue(SvgDrawContext context, String rawColorValue, float objectBoundingBoxMargin
, float parentOpacity)
{
if (rawColorValue == null)
{
return(null);
}
CssDeclarationValueTokenizer tokenizer = new CssDeclarationValueTokenizer(rawColorValue);
CssDeclarationValueTokenizer.Token token = tokenizer.GetNextValidToken();
if (token == null)
{
return(null);
}
String tokenValue = token.GetValue();
if (tokenValue.StartsWith("url(#") && tokenValue.EndsWith(")"))
{
Color resolvedColor = null;
float resolvedOpacity = 1;
String normalizedName = tokenValue.JSubstring(5, tokenValue.Length - 1).Trim();
ISvgNodeRenderer colorRenderer = context.GetNamedObject(normalizedName);
if (colorRenderer is AbstractGradientSvgNodeRenderer)
{
resolvedColor = ((AbstractGradientSvgNodeRenderer)colorRenderer).CreateColor(context, GetObjectBoundingBox
(context), objectBoundingBoxMargin, parentOpacity);
}
if (resolvedColor != null)
{
return(new TransparentColor(resolvedColor, resolvedOpacity));
}
token = tokenizer.GetNextValidToken();
}
// may become null after function parsing and reading the 2nd token
if (token != null)
{
String value = token.GetValue();
if (!SvgConstants.Values.NONE.EqualsIgnoreCase(value))
{
return(new TransparentColor(WebColors.GetRGBColor(value), parentOpacity * GetAlphaFromRGBA(value)));
}
}
return(null);
}
public virtual void NestedProcessedRendererTest()
{
iText.StyledXmlParser.Jsoup.Nodes.Element parentEl = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("processable"), "");
iText.StyledXmlParser.Jsoup.Nodes.Element childEl = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("processable"), "");
IElementNode parentTag = new JsoupElementNode(parentEl);
IElementNode childTag = new JsoupElementNode(childEl);
ISvgNodeRenderer parentRenderer = fact.CreateSvgNodeRendererForTag(parentTag, null);
ISvgNodeRenderer childRenderer = fact.CreateSvgNodeRendererForTag(childTag, parentRenderer);
parentRenderer.Draw(new SvgDrawContext(null, null));
DummyProcessableSvgNodeRenderer parentProcessed = (DummyProcessableSvgNodeRenderer)parentRenderer;
NUnit.Framework.Assert.IsTrue(parentProcessed.IsProcessed());
DummyProcessableSvgNodeRenderer childProcessed = (DummyProcessableSvgNodeRenderer)childRenderer;
// child is not processed unless instructed thus in its parent
NUnit.Framework.Assert.IsFalse(childProcessed.IsProcessed());
}
public virtual void DefaultProcessingTestPassedPropertiesNull()
{
//Setup nodes
iText.StyledXmlParser.Jsoup.Nodes.Element jsoupSVGRoot = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("svg"), "");
iText.StyledXmlParser.Jsoup.Nodes.Element jsoupSVGCircle = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("circle"), "");
iText.StyledXmlParser.Jsoup.Nodes.Element jsoupSVGPath = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("path"), "");
INode root = new JsoupElementNode(jsoupSVGRoot);
root.AddChild(new JsoupElementNode(jsoupSVGCircle));
root.AddChild(new JsoupElementNode(jsoupSVGPath));
//Run
DefaultSvgProcessor processor = new DefaultSvgProcessor();
ISvgNodeRenderer rootActual = processor.Process(root, null).GetRootRenderer();
//Compare
NUnit.Framework.Assert.IsNull(rootActual);
}
public virtual void DummyProcessingTestNodeHasNullChild()
{
iText.StyledXmlParser.Jsoup.Nodes.Element jsoupSVGRoot = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("svg"), "");
iText.StyledXmlParser.Jsoup.Nodes.Element jsoupSVGCircle = new iText.StyledXmlParser.Jsoup.Nodes.Element(iText.StyledXmlParser.Jsoup.Parser.Tag
.ValueOf("circle"), "");
INode root = new JsoupElementNode(jsoupSVGRoot);
root.AddChild(new JsoupElementNode(jsoupSVGCircle));
root.AddChild(null);
root.AddChild(new JsoupElementNode(jsoupSVGCircle));
//Run
DefaultSvgProcessor processor = new DefaultSvgProcessor();
ISvgConverterProperties props = new DummySvgConverterProperties();
ISvgNodeRenderer rootActual = processor.Process(root, props).GetRootRenderer();
//setup expected
ISvgNodeRenderer rootExpected = new DummySvgNodeRenderer("svg");
NUnit.Framework.Assert.AreEqual(rootExpected, rootActual);
}
/// <summary>
/// Create an
/// <see cref="iText.Kernel.Pdf.Xobject.PdfFormXObject"/>
/// tied to the passed
/// <c>PdfDocument</c>
/// using the SVG processing result.
/// </summary>
/// <param name="result">Processing result containing the SVG information</param>
/// <param name="pdfDocument">pdf that shall contain the image</param>
/// <returns>PdfFormXObject instance</returns>
public virtual PdfFormXObject CreateXObjectFromProcessingResult(ISvgProcessorResult result, PdfDocument pdfDocument
)
{
ISvgNodeRenderer topSvgRenderer = result.GetRootRenderer();
float width;
float height;
float[] wh = SvgConverter.ExtractWidthAndHeight(topSvgRenderer);
width = wh[0];
height = wh[1];
PdfFormXObject pdfForm = new PdfFormXObject(new Rectangle(0, 0, width, height));
PdfCanvas canvas = new PdfCanvas(pdfForm, pdfDocument);
SvgDrawContext context = new SvgDrawContext(null, result.GetFontProvider());
context.AddNamedObjects(result.GetNamedObjects());
context.PushCanvas(canvas);
ISvgNodeRenderer root = new PdfRootSvgNodeRenderer(topSvgRenderer);
root.Draw(context);
return(pdfForm);
}
protected internal virtual void ApplyStyles(ISvgNodeRenderer parent, ISvgNodeRenderer child)
{
if (parent != null && child != null)
{
IDictionary <String, String> childStyles = child.GetAttributeMapCopy();
if (childStyles == null)
{
childStyles = new Dictionary <String, String>();
}
IDictionary <String, String> parentStyles = parent.GetAttributeMapCopy();
String parentFontSize = parent.GetAttribute(SvgConstants.Attributes.FONT_SIZE);
if (parentFontSize == null)
{
parentFontSize = "0";
}
foreach (KeyValuePair <String, String> parentAttribute in parentStyles)
{
sru.MergeParentStyleDeclaration(childStyles, parentAttribute.Key, parentAttribute.Value, parentFontSize);
}
child.SetAttributesAndStyles(childStyles);
}
}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}
){kind=link}