public unsafe void PopulateCharColorData(CharInfo ci, IFontProvider font)
{
ColorF charRGB = ColorF.Init;
for (int ty = 0; ty < LumaTiles.Height; ++ty)
{
for (int tx = 0; tx < LumaTiles.Width; ++tx)
{
Size tileSize;
Point tilePos;
GetTileInfo(font.CharSizeNoPadding, LumaTiles, tx, ty, out tilePos, out tileSize);
// process this single tile of this char.
// grab all pixels for this tile and calculate Y component for each
ColorF tileRGB = font.GetRegionColor(ci.srcIndex, tilePos, tileSize, LumaTiles, tx, ty);
charRGB = charRGB.Add(tileRGB);
LCCColorDenorm tileLAB = Colorspace.RGBToLCC(tileRGB);
ci.actualValues.DenormalizedValues[GetValueLIndex(tx, ty)] = (float)tileLAB.L;
ci.actualValues.NormalizedValues[GetValueLIndex(tx, ty)] = (float)Colorspace.NormalizeL(ci.actualValues.DenormalizedValues[GetValueLIndex(tx, ty)]);
}
}
if (UseChroma)
{
charRGB = charRGB.Div(Utils.Product(LumaTiles));
LCCColorDenorm charLAB = Colorspace.RGBToLCC(charRGB);
ci.actualValues.DenormalizedValues[GetValueC1Index()] = (float)charLAB.C1;
ci.actualValues.DenormalizedValues[GetValueC2Index()] = (float)charLAB.C2;
ci.actualValues.NormalizedValues[GetValueC1Index()] = (float)Colorspace.NormalizeC1(ci.actualValues.DenormalizedValues[GetValueC1Index()]);
ci.actualValues.NormalizedValues[GetValueC2Index()] = (float)Colorspace.NormalizeC2(ci.actualValues.DenormalizedValues[GetValueC2Index()]);
}
}
public Text(ILogger logger, IFontProvider fontProvider, ApplicationWindow applicationWindow, ColorTextureVao vao)
{
this.logger = logger;
this.fontProvider = fontProvider;
this.vao = vao;
vao.Initialize();
vao.SetTopLeftCorner(new Vector2(0, 0), new Vector2(applicationWindow.Width, applicationWindow.Height));
vao.SetupColors(new Color4[] { Color4.White, Color4.White, Color4.White, Color4.White });
vao.SetupTextureCoords(new Vector2[] { new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1), new Vector2(1, 0) });
bitmap = new Bitmap(applicationWindow.Width, applicationWindow.Height);
graphics = System.Drawing.Graphics.FromImage(bitmap);
graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
textureId = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, textureId);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, applicationWindow.Width, applicationWindow.Height, 0,
PixelFormat.Rgba, PixelType.UnsignedByte, IntPtr.Zero);
}
protected virtual void TransformHtml2Pdf(Document doc, PdfWriter pdfWriter, IImageProvider imageProvider,
IFontProvider fontProvider, Stream cssFile)
{
CssFilesImpl cssFiles = new CssFilesImpl();
if (cssFile == null)
{
cssFile =
typeof(XMLWorker).Assembly.GetManifestResourceStream("iTextSharp.tool.xml.css.default.css");
}
cssFiles.Add(XMLWorkerHelper.GetCSS(cssFile));
StyleAttrCSSResolver cssResolver = new StyleAttrCSSResolver(cssFiles);
HtmlPipelineContext hpc;
if (fontProvider != null)
{
hpc = new HtmlPipelineContext(new CssAppliersImpl(fontProvider));
}
else
{
hpc = new HtmlPipelineContext(null);
}
hpc.SetImageProvider(imageProvider);
hpc.SetAcceptUnknown(true).AutoBookmark(true).SetTagFactory(Tags.GetHtmlTagProcessorFactory());
HtmlPipeline htmlPipeline = new HtmlPipeline(hpc, new PdfWriterPipeline(doc, pdfWriter));
IPipeline pipeline = new CssResolverPipeline(cssResolver, htmlPipeline);
XMLWorker worker = new XMLWorker(pipeline, true);
XMLParser xmlParse = new XMLParser(true, worker, Encoding.GetEncoding("UTF-8"));
xmlParse.Parse(File.OpenRead(inputHtml), Encoding.GetEncoding("UTF-8"));
}
public ThemeStyler(IFontProvider fontProvider, IThemeCollection themes)
{
state = new StyleConfiguratorState(themes)
{
Fonts = fontProvider
};
}
protected override void TransformHtml2Pdf(Document doc, PdfWriter pdfWriter, IImageProvider imageProvider,
IFontProvider fontProvider, Stream cssFile)
{
ICSSResolver cssResolver = XMLWorkerHelper.GetInstance().GetDefaultCssResolver(true);
HtmlPipelineContext hpc;
if (fontProvider != null)
{
hpc = new HtmlPipelineContext(new CssAppliersImpl(fontProvider));
}
else
{
hpc = new HtmlPipelineContext(null);
}
hpc.SetImageProvider(imageProvider);
hpc.SetAcceptUnknown(true).AutoBookmark(true).SetTagFactory(Tags.GetHtmlTagProcessorFactory());
HtmlPipeline htmlPipeline = new HtmlPipeline(hpc, new PdfWriterPipeline(doc, pdfWriter));
IPipeline pipeline = new CssResolverPipeline(cssResolver, htmlPipeline);
XMLWorker worker = new XMLWorker(pipeline, true);
XMLParser xmlParse = new XMLParser(true, worker, Encoding.UTF8);
xmlParse.Parse(new FileStream(inputHtml, FileMode.Open), Encoding.UTF8);
}
public ContentLayoutEngine(IFontProvider fonts)
{
this.fonts = fonts;
commands.Add("color", new SetTextColor());
commands.Add("scale", new SetTextScale());
commands.Add("reset", new ResetFont());
}
public static void DrawString(
this RenderContext context,
IFontProvider font,
string text,
float x,
float y,
Color color
) => context.DrawString(font, text, x, y, (_, _, p) => new(p) { Color = color });
public ThemeLoader(IFontProvider fonts)
{
deserializer = new DeserializerBuilder()
.WithNamingConvention(new HyphenatedNamingConvention())
.WithTypeConvertersForBasicStructures()
.WithTypeConverter(new ImageSourceYamlConverter())
.Build();
this.fonts = fonts;
}
public GroupCoverRenderer(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_imageRender = serviceProvider.GetService <IImageRender>();
using (var background = Image.FromFile(GetBackgroundImagePath()))
{
_imageRender.CreateFromImage(background);
}
_fontProvider = serviceProvider.GetService <IFontProvider>();
}
public AgateConsoleScene(AgateConsole console, IFontProvider fontProvider)
{
this.console = console;
this.fontProvider = fontProvider;
UpdateBelow = false;
DrawBelow = true;
console.ConsoleClosed += () => IsFinished = true;
}
private static IFontProvider GetFontProviderBy(PdfFont font)
{
IFontProvider fontProvider = null;
if (font == PdfFont.Arial)
{
fontProvider = new CustomFontProvider();
}
return(fontProvider);
}
public ChunkCssApplier(IFontProvider fontProvider)
{
if (fontProvider != null)
{
this.fontProvider = fontProvider;
}
else
{
this.fontProvider = new FontFactoryImp();
}
}
public GLMeasureContext(IFontProvider fontProvider,
IVisualSurrogateProvider surrogateProvider,
Dictionary <IVisualElement, ValueSize> lastMeasurements,
IThemeProvider themeProvider,
IVisualLineage visualLineage,
ILayoutQueue layoutQueue)
: base(surrogateProvider, lastMeasurements,
themeProvider, visualLineage, layoutQueue)
{
_fontProvider = fontProvider;
}
public ChunkCssApplier(IFontProvider fontProvider)
{
if (fontProvider != null)
{
this.fontProvider = fontProvider;
}
else
{
this.fontProvider = new FontFactoryImp();
}
}
public UserInterfaceScene(GraphicsDevice graphicsDevice,
IUserInterfaceRenderer userInterfaceRenderer,
IContentLayoutEngine contentLayoutEngine,
IFontProvider fontProvider,
IStyleConfigurator styleConfigurator,
IAnimationFactory animationFactory = null,
IUserInterfaceAudio audio = null,
IDoubleBuffer doubleBuffer = null,
RenderTarget2D renderTarget = null)
{
DrawBelow = true;
UpdateBelow = false;
Animations = animationFactory ?? new AnimationFactory();
GraphicsDevice = graphicsDevice;
renderContext = new UserInterfaceRenderContext(
graphicsDevice,
contentLayoutEngine,
userInterfaceRenderer,
styleConfigurator,
fontProvider,
Animations,
renderTarget,
null,
doubleBuffer);
driver = new UserInterfaceSceneDriver(
renderContext,
styleConfigurator,
fontProvider,
audio);
driver.ScreenArea = new Rectangle(Point.Zero,
GraphicsDeviceRenderTargetSize);
driver.Desktop.Empty += () =>
{
if (ExitWhenEmpty)
{
IsFinished = true;
}
};
BlendState = new BlendState
{
ColorSourceBlend = Blend.SourceAlpha,
ColorDestinationBlend = Blend.InverseSourceAlpha,
AlphaSourceBlend = Blend.One,
AlphaDestinationBlend = Blend.InverseSourceAlpha,
};
}
public GLRenderContext(IViewPerspective perspective,
IGLContext openGlContext,
IFontProvider fontProvider,
IVisualSurrogateProvider surrogateProvider,
IThemeProvider themeProvider,
IVisualLineage visualLineage,
Dictionary <IVisualElement, ValueCube> renderPositions,
ILayoutQueue layoutQueue)
: base(perspective, surrogateProvider, themeProvider,
visualLineage, renderPositions, layoutQueue)
{
_openGlContext = openGlContext;
_fontProvider = fontProvider;
}
void AddFont(IFontProvider fontProvider)
{
var font = fontProvider.GetFont();
for (uint i = 0; i < 94; ++i)
{
AddTexture(Layer.Text, i, font.GetGlyphGraphic(i));
}
// Add simple digits for damage display
for (uint i = 0; i < 10; ++i)
{
AddTexture(Layer.Text, 100 + i, font.GetDigitGlyphGraphic(i));
}
}
public unsafe void PopulateCharColorData(CharInfo ci, IFontProvider font)
{
ColorF charRGB = ColorF.Init;
ColorF[] lumaRGB = new ColorF[LumaComponentCount];
int[] pixelCounts = new int[LumaComponentCount];
for (int i = 0; i < LumaComponentCount; ++i)
{
lumaRGB[i] = ColorF.Init;
pixelCounts[i] = 0;
}
for (int py = 0; py < font.CharSizeNoPadding.Height; ++py)
{
for (int px = 0; px < font.CharSizeNoPadding.Width; ++px)
{
ColorF pc = font.GetPixel(ci.srcIndex, px, py);
charRGB = charRGB.Add(pc);
int lumaIdx = Tessellator.GetLumaTileIndexOfPixelPosInCell(px, py, font.CharSizeNoPadding);
lumaRGB[lumaIdx] = lumaRGB[lumaIdx].Add(pc);
pixelCounts[lumaIdx]++;
}
}
for (int i = 0; i < LumaComponentCount; ++i)
{
var pc = pixelCounts[i];
var lc = lumaRGB[i];
if (pixelCounts[i] < 1)
{
throw new Exception("!!!!!! Your fonts are just too small; i can't sample them properly.");
}
lc = lc.Div(pc);
LCCColorDenorm lccc = Colorspace.RGBToLCC(lc);
ci.actualValues.DenormalizedValues[i] = (float)lccc.L;
ci.actualValues.NormalizedValues[i] = (float)Colorspace.NormalizeL(ci.actualValues.DenormalizedValues[i]);
}
if (UseChroma)
{
charRGB = charRGB.Div(Utils.Product(font.CharSizeNoPadding));
LCCColorDenorm charLAB = Colorspace.RGBToLCC(charRGB);
ci.actualValues.DenormalizedValues[GetValueC1Index()] = (float)charLAB.C1;
ci.actualValues.DenormalizedValues[GetValueC2Index()] = (float)charLAB.C2;
ci.actualValues.NormalizedValues[GetValueC1Index()] = (float)Colorspace.NormalizeC1(ci.actualValues.DenormalizedValues[GetValueC1Index()]);
ci.actualValues.NormalizedValues[GetValueC2Index()] = (float)Colorspace.NormalizeC2(ci.actualValues.DenormalizedValues[GetValueC2Index()]);
}
}
public UserInterfaceSceneDriver(
IUserInterfaceRenderContext renderContext,
IStyleConfigurator styles,
IFontProvider fonts,
IUserInterfaceAudio audio = null)
{
this.renderContext = renderContext;
desktop = new Desktop(fonts, styles);
desktop.Audio = audio;
Desktop.UnhandledEvent += Desktop_UnhandledEvent;
uiInput.UIAction += desktop.OnUserInterfaceAction;
}
public FrequencyTagsCloudWrapper(IFontProvider fontCreator, FrequencyWrapperSettings settings, ITagsCreator tagsCreator)
{
FontCreator = fontCreator;
Settings = settings;
tagsFrequency = new Dictionary <string, int>();
foreach (var tag in tagsCreator.GetTags())
{
if (!tagsFrequency.ContainsKey(tag))
{
tagsFrequency[tag] = 0;
}
tagsFrequency[tag]++;
MaxFrequency = Math.Max(MaxFrequency, tagsFrequency[tag]);
}
}
/**
* Setter for the providers.
* If a FontProvider is added, the ElementFactory is updated.
* @param providers a IDictionary with different providers
* @since 5.0.6
*/
public void SetProviders(IDictionary <String, Object> providers)
{
if (providers == null)
{
return;
}
this.providers = providers;
IFontProvider ff = null;
if (providers.ContainsKey(FONT_PROVIDER))
{
ff = (IFontProvider)providers[FONT_PROVIDER];
}
if (ff != null)
{
factory.FontProvider = ff;
}
}
protected override void TransformHtml2Pdf(Document doc, PdfWriter pdfWriter, IImageProvider imageProvider,
IFontProvider fontProvider, Stream cssFile) {
ICSSResolver cssResolver = XMLWorkerHelper.GetInstance().GetDefaultCssResolver(true);
HtmlPipelineContext hpc;
if (fontProvider != null)
hpc = new HtmlPipelineContext(new CssAppliersImpl(fontProvider));
else
hpc = new HtmlPipelineContext(null);
hpc.SetImageProvider(imageProvider);
hpc.SetAcceptUnknown(true).AutoBookmark(true).SetTagFactory(Tags.GetHtmlTagProcessorFactory());
HtmlPipeline htmlPipeline = new HtmlPipeline(hpc, new PdfWriterPipeline(doc, pdfWriter));
IPipeline pipeline = new CssResolverPipeline(cssResolver, htmlPipeline);
XMLWorker worker = new XMLWorker(pipeline, true);
XMLParser xmlParse = new XMLParser(true, worker, Encoding.UTF8);
xmlParse.Parse(new FileStream(inputHtml, FileMode.Open), Encoding.UTF8);
}
public static FiveTilePixelFormat ProcessArgs(string[] args, IFontProvider font)
{
FiveTilePixelFormat ret = new FiveTilePixelFormat();
//ret.Rotation = 0.5f;
int valuesPerComponent = 255;
args.ProcessArg("-pfargs", s =>
{
valuesPerComponent = int.Parse(s.Split('v')[0]);
ret.UseChroma = int.Parse(s.Split('+')[1]) > 1;
});
args.ProcessArg("-tessellator", s =>
{
switch (s.ToLowerInvariant())
{
case "a":
ret.Tessellator = new FiveTileTesselatorA();
break;
case "b":
ret.Tessellator = new FiveTileTesselatorB();
break;
case "c":
ret.Tessellator = new FiveTileTesselatorC();
break;
}
});
if (ret.Tessellator == null)
{
ret.Tessellator = new FiveTileTesselatorB();
}
ret.Colorspace = Utils.ParseRequiredLCCColorSpaceArgs(args);
ret.ChromaComponentCount = (ret.UseChroma ? 2 : 0);
ret.DimensionCount = ret.LumaComponentCount + ret.ChromaComponentCount;
ret.DiscreteNormalizedValues = Utils.GetDiscreteNormalizedValues(valuesPerComponent);
Utils.DumpTessellation(ret.Tessellator, font.CharSizeNoPadding);
return(ret);
}
public static HybridMap2 LoadFromDisk(string dir, IFontProvider f, IPixelFormatProvider pf)
{
HybridMap2 ret = new HybridMap2();
Log.WriteLine("Loading charinfo...");
string sci = System.IO.File.ReadAllText(System.IO.Path.Combine(dir, "CharInfo.json"));
ret.CharInfo = Newtonsoft.Json.JsonConvert.DeserializeObject <CharInfo[]>(sci);
Log.WriteLine("Loading DistinctMappedChars...");
string sdmc = System.IO.File.ReadAllText(System.IO.Path.Combine(dir, "DistinctMappedChars.json"));
ret.DistinctMappedChars = Newtonsoft.Json.JsonConvert.DeserializeObject <CharInfo[]>(sdmc);
ret.FontProvider = f;
ret.PixelFormatProvider = pf;
return(ret);
}
public UserInterfaceRenderContext(
GraphicsDevice graphicsDevice,
IContentLayoutEngine contentLayoutEngine,
IUserInterfaceRenderer uiRenderer,
IStyleConfigurator styleConfigurator,
IFontProvider fonts,
IAnimationFactory animation,
RenderTarget2D renderTarget = null,
SpriteBatch spriteBatch = null,
IDoubleBuffer doubleBuffer = null)
{
this.GraphicsDevice = graphicsDevice;
this.contentLayoutEngine = contentLayoutEngine;
this.UserInterfaceRenderer = uiRenderer;
this.fonts = fonts;
this.animationFactory = animation;
this.RenderTarget = renderTarget;
this.SpriteBatch = spriteBatch ?? new SpriteBatch(graphicsDevice);
this.DoubleBuffer = doubleBuffer ?? new DoubleBuffer();
}
public ViewerState(IFrameBufferWindow frameBuffer, Document doc, int width, int height, IFontProvider fontProvider = null, string font = null)
{
Cursor = new Cursor(this);
Document = doc;
_cursorInverted = false;
_frameBuffer = frameBuffer;
_renderBuffer = new byte[width * height];
_fontProvider = fontProvider ?? new TempleOSFontProvider();
Font = _fontProvider.Get(font);
Width = width;
Height = height;
Rows = height / Font.Height;
Columns = width / Font.Width;
RawMode = false;
doc.OnUpdate += Document_OnUpdate;
Pages = new CharacterPageDirectory(Columns, Rows);
}
public TestUIDriver(IRenderable app,
IStyleConfigurator styleConfigurator = null,
IFontProvider fontProvider = null,
IContentLayoutEngine contentLayoutEngine = null)
{
var renderContext = CommonMocks.RenderContext(contentLayoutEngine).Object;
uiDriver = new UserInterfaceSceneDriver(
renderContext,
styleConfigurator ?? new ThemeStyler(new ThemeCollection {
["default"] = Theme.CreateDefaultTheme()
}),
fontProvider ?? CommonMocks.FontProvider().Object);
defaultWorkspace = new Workspace("default", app);
input = new ManualInputState();
uiDriver.Desktop.PushWorkspace(defaultWorkspace);
DoLayout();
}
public OpenGLRenderKit(IFontProvider fontProvider,
IGLContext glContext,
IThemeProvider themeProvider,
IImageProvider imageProvider)
: base(imageProvider, Serializer,
new SvgPathBuilder(imageProvider, Serializer), null)
//: base(themeProvider, Serializer.AttributeParser,
// Serializer.TypeInferrer, Serializer.TypeManipulator,
// new Dictionary<IVisualElement, ValueCube>(), imageProvider,
// Serializer.AssemblyList, Serializer)
{
var lastMeasurements = new Dictionary <IVisualElement, ValueSize>();
var lastRender = new Dictionary <IVisualElement, ValueCube>();
var visualLineage = new VisualLineage();
var layoutQueue = new LayoutQueue();
MeasureContext = new GLMeasureContext(fontProvider, this,
lastMeasurements, themeProvider, visualLineage, layoutQueue);
RenderContext = new GLRenderContext(new BasePerspective(),
glContext, fontProvider, this, themeProvider,
visualLineage, lastRender, layoutQueue);
}
virtual public void ParseXHtml(PdfWriter writer, Document doc, Stream inp, Stream inCssFile, Encoding charset,
IFontProvider fontProvider) {
ParseXHtml(writer, doc, inp, inCssFile, charset, fontProvider, null);
}
public CssAppliersImpl(IFontProvider fontProvider)
: this()
{
chunk.FontProvider = fontProvider;
}
public void ParseXHtml(PdfWriter writer, Document doc, Stream inp, Stream inCssFile, IFontProvider fontProvider) {
ParseXHtml(writer, doc, inp, inCssFile, null, fontProvider);
}
public void ParseXHtml(PdfWriter writer, Document doc, Stream inp, Stream inCssFile, Encoding charset, IFontProvider fontProvider) {
CssFilesImpl cssFiles = new CssFilesImpl();
if (inCssFile != null)
cssFiles.Add(GetCSS(inCssFile));
else
cssFiles.Add(GetDefaultCSS());
StyleAttrCSSResolver cssResolver = new StyleAttrCSSResolver(cssFiles);
HtmlPipelineContext hpc = new HtmlPipelineContext(new CssAppliersImpl(fontProvider));
hpc.SetAcceptUnknown(true).AutoBookmark(true).SetTagFactory(GetDefaultTagProcessorFactory());
HtmlPipeline htmlPipeline = new HtmlPipeline(hpc, new PdfWriterPipeline(doc, writer));
IPipeline pipeline = new CssResolverPipeline(cssResolver, htmlPipeline);
XMLWorker worker = new XMLWorker(pipeline, true);
XMLParser p = new XMLParser(true, worker, charset);
if (charset != null) {
p.Parse(inp, charset);
} else {
p.Parse(inp);
}
}
virtual public void ParseXHtml(PdfWriter writer, Document doc, Stream inp, Stream inCssFile, IFontProvider fontProvider)
{
ParseXHtml(writer, doc, inp, inCssFile, null, fontProvider);
}
public ConsoleTextEngine(IFontProvider fontProvider)
{
consoleFontProvider = fontProvider;
contentLayoutEngine = new ContentLayoutEngine(consoleFontProvider);
}
public CssAppliersImpl(IFontProvider fontProvider)
: this()
{
((ChunkCssApplier)map[typeof(Chunk)]).FontProvider = fontProvider;
}
public GetXPImageStreamQueryHandler(IFontProvider fontProvider, ITemplateFileProvider templateFileProvider)
{
_fontProvider = fontProvider;
_templateFileProvider = templateFileProvider;
}
public void FontProviderConnectionPoint(IFontProvider provider)
{
FontProvider = provider;
}
protected void TransformHtml2Pdf(Document doc, PdfWriter pdfWriter, IImageProvider imageProvider,
IFontProvider fontProvider, Stream cssFile) {
CssFilesImpl cssFiles = new CssFilesImpl();
if (cssFile == null)
cssFile =
typeof (XMLWorker).Assembly.GetManifestResourceStream("iTextSharp.tool.xml.css.default.css");
cssFiles.Add(XMLWorkerHelper.GetCSS(cssFile));
StyleAttrCSSResolver cssResolver = new StyleAttrCSSResolver(cssFiles);
HtmlPipelineContext hpc;
if (fontProvider != null)
hpc = new HtmlPipelineContext(new CssAppliersImpl(fontProvider));
else
hpc = new HtmlPipelineContext(null);
hpc.SetImageProvider(imageProvider);
hpc.SetAcceptUnknown(true).AutoBookmark(true).SetTagFactory(Tags.GetHtmlTagProcessorFactory());
HtmlPipeline htmlPipeline = new HtmlPipeline(hpc, new PdfWriterPipeline(doc, pdfWriter));
IPipeline pipeline = new CssResolverPipeline(cssResolver, htmlPipeline);
XMLWorker worker = new XMLWorker(pipeline, true);
XMLParser xmlParse = new XMLParser(true, worker, Encoding.GetEncoding("UTF-8"));
xmlParse.Parse(File.OpenRead(inputHtml), Encoding.GetEncoding("UTF-8"));
}
