protected override void OnDetached()
{
if (Control != null)
{
Control cntrl = Control as Control;
if (cntrl != null)
{
cntrl.Background = prevBrush;
}
}
else
{
LayoutRenderer renderer = Container as LayoutRenderer;
if (renderer != null)
{
renderer.Background = prevBrush;
}
else
{
PageRenderer prenderer = Container as PageRenderer;
if (prenderer != null)
{
prenderer.Background = prevBrush;
}
}
}
prevBrush = null;
}
public void Ensure_Callbacks_Exeuted_In_Correct_Order()
{
var page = TemplatePageTest.CreatePage(v => { });
var callbackRecords = new List <string>();
var context = new PageContext();
context.PrerenderCallbacks.Add((t) =>
{
callbackRecords.Add("PAGE_SPECIFIC_CALLBACK");
});
page.PageContext = context;
var renderer = new PageRenderer(page, CreateLookupForPageInstance(page));
renderer.PreRenderCallbacks.Add(new Action <TemplatePage>((t) =>
{
callbackRecords.Add("GLOBAL_CALLBACK");
}));
using (var writer = new StringWriter())
{
page.PageContext.Writer = writer;
renderer.RenderAsync(context).Wait();
}
Assert.True(callbackRecords.Count == 2);
Assert.Equal(callbackRecords[0], "PAGE_SPECIFIC_CALLBACK");
Assert.Equal(callbackRecords[1], "GLOBAL_CALLBACK");
}
private void SaveToStream(SKWStream stream)
{
var metadata = new SKDocumentPdfMetadata
{
Author = Author,
Creation = DateTime.Now,
Creator = Creator,
Keywords = Keywords,
Modified = DateTime.Now,
Producer = Producer,
Subject = Subject,
Title = Title,
};
int dpi = 72;
using (var document = SKDocument.CreatePdf(stream, metadata, dpi))
{
foreach (var page in Pages)
{
var pdfCanvas = document.BeginPage(page.Width, page.Height, page.Dimensions.GetContentRect().ToSKRect());
var pageRenderer = new PageRenderer(page);
pageRenderer.Render(pdfCanvas);
document.EndPage();
}
// end the doc
document.Close();
}
}
public static void SetBackButtonImage(this PageRenderer pageRenderer, string path)
{
if (pageRenderer.NavigationController != null &&
!pageRenderer.NavigationController.TopViewController.NavigationItem.HidesBackButton &&
pageRenderer.Element.Navigation.NavigationStack[0] != pageRenderer.Element)
{
pageRenderer.NavigationController.TopViewController.NavigationItem.SetHidesBackButton(true, false);
var backImage = UIImage.FromBundle(path);
var customBackButton = new UIButton(UIButtonType.Custom);
customBackButton.SetImage(backImage, UIControlState.Normal);
customBackButton.SetImage(backImage, UIControlState.Highlighted);
customBackButton.Frame = new CoreGraphics.CGRect(0, 0, backImage.Size.Width + navigatigationBarLeftRightPadding, 44);
customBackButton.ContentEdgeInsets = new UIEdgeInsets(0, navigatigationBarLeftRightPadding, 0, 0);
customBackButton.AddTarget((sender, args) =>
{
var page = ((Page)pageRenderer.Element);
if (page.Navigation != null)
{
page.SendBackButtonPressed();
page.Navigation.PopAsync(true);
}
}, UIControlEvent.TouchUpInside);
var barBackButton = new UIBarButtonItem(customBackButton);
// Remove left padding of back button
var negativeSeparator = new UIBarButtonItem(UIBarButtonSystemItem.FixedSpace);
negativeSeparator.Width = -navigatigationBarLeftRightPadding;
pageRenderer.NavigationController.TopViewController.NavigationItem.SetLeftBarButtonItems(new[] { negativeSeparator, barBackButton }, false);
}
}
private async void loadPages(string path)
{
using (PageRenderer pr = new PageRenderer(path))
{
pbProgress.Maximum = pr.PageCount;
for (int i = 0; i < pr.PageCount; i++)
{
ListViewItem itm = new ListViewItem("Page " + (i + 1));
itm.ImageIndex = i;
itm.Checked = true;
lvPages.Items.Add(itm);
}
for (int i = 0; i < pr.PageCount; i++)
{
Task <Bitmap> t = new Task <Bitmap>(() => pr.RenderPage(i, imgPages.ImageSize.Height));
t.Start();
imgPages.Images.Add(await t);
pbProgress.Value++;
lblProgress.Text = $"{i + 1}/{pr.PageCount}";
}
pnProgress.Hide();
btnCancel.Enabled = true;
btnOk.Enabled = true;
}
}
public void ProcessRequest(HttpContext context)
{
var functionName = (string)context.Request.RequestContext.RouteData.Values["function"];
var dataCulture = GetCurrentDataCulture(context);
using (var data = new DataConnection())
{
if (!data.Get <IFunctionRoute>().Any())
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
}
IFunction function;
if (!FunctionFacade.TryGetFunction(out function, functionName))
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
using (var dataScope = new DataScope(DataScopeIdentifier.Public, dataCulture))
{
var functionResult = FunctionFacade.Execute <object>(function, context.Request.QueryString);
if (functionResult == null)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
var xhtmlDocument = functionResult as XhtmlDocument;
if (xhtmlDocument != null)
{
PageRenderer.ExecuteEmbeddedFunctions(xhtmlDocument.Root, new FunctionContextContainer());
PageRenderer.NormalizeXhtmlDocument(xhtmlDocument);
var xhtml = xhtmlDocument.ToString();
xhtml = PageUrlHelper.ChangeRenderingPageUrlsToPublic(functionResult.ToString());
xhtml = MediaUrlHelper.ChangeInternalMediaUrlsToPublic(xhtml);
context.Response.Write(xhtml);
}
else
{
context.Response.Write(functionResult.ToString());
if (functionResult is XNode && function.ReturnType != typeof(XhtmlDocument))
{
context.Response.ContentType = "text/xml";
}
}
}
}
public XDocument Render(PageContentToRender contentToRender, FunctionContextContainer functionContextContainer)
{
var document = TemplateInfo.GetTemplateDocument(contentToRender.Page.TemplateId);
PageRenderer.ResolvePlaceholders(document, contentToRender.Contents);
return(document);
}
public void Init(ISlideOverKitPageRendererDroid menuKit)
{
_menuKit = menuKit;
_pageRenderer = menuKit as PageRenderer;
_menuKit.OnElementChangedEvent = OnElementChanged;
_menuKit.OnLayoutEvent = OnLayout;
_menuKit.OnSizeChangedEvent = OnSizeChanged;
}
public void Init(ISlideOverKitPageRendererDroid menuKit)
{
_menuKit = menuKit;
_pageRenderer = menuKit as PageRenderer;
_menuKit.OnElementChangedEvent = OnElementChanged;
_menuKit.OnLayoutEvent = OnLayout;
_menuKit.OnSizeChangedEvent = OnSizeChanged;
}
public static void HideBackButton(this PageRenderer pageRenderer, bool value)
{
foreach (var item in pageRenderer.NavigationController.TopViewController.NavigationItem.LeftBarButtonItems)
{
if (item.CustomView != null)
{
item.CustomView.Hidden = value;
}
}
}
/// <exclude />
protected override void OnInit(System.EventArgs e)
{
XhtmlDocument feature = PageTemplateFeatureFacade.GetPageTemplateFeature(this.Name);
FunctionContextContainer functionContextContainer = PageRenderer.GetPageRenderFunctionContextContainer();
var markup = new Markup(feature.Root, functionContextContainer);
Controls.Add(markup);
base.OnInit(e);
}
public void Init(ISlideOverKitPageRendereriOS menuKit)
{
_menuKit = menuKit;
_pageRenderer = menuKit as PageRenderer;
_menuKit.ViewDidAppearEvent = ViewDidAppear;
_menuKit.OnElementChangedEvent = OnElementChanged;
_menuKit.ViewDidLayoutSubviewsEvent = ViewDidLayoutSubviews;
_menuKit.ViewDidDisappearEvent = ViewDidDisappear;
_menuKit.ViewWillTransitionToSizeEvent = ViewWillTransitionToSize;
}
/// <summary>
/// Binds placeholders' content to the related properties on a template definition
/// </summary>
/// <param name="template">The template.</param>
/// <param name="pageContentToRender">The page rendering job.</param>
/// <param name="placeholderProperties">The placeholder properties.</param>
/// <param name="functionContextContainer">The function context container, if not null, nested functions fill be evaluated.</param>
public static void BindPlaceholders(IPageTemplate template,
PageContentToRender pageContentToRender,
IDictionary <string, PropertyInfo> placeholderProperties,
FunctionContextContainer functionContextContainer)
{
Verify.ArgumentNotNull(template, "template");
Verify.ArgumentNotNull(pageContentToRender, "pageContentToRender");
Verify.ArgumentNotNull(placeholderProperties, "placeholderProperties");
foreach (var placeholderContent in pageContentToRender.Contents)
{
string placeholderId = placeholderContent.PlaceHolderId;
if (!placeholderProperties.ContainsKey(placeholderId))
{
continue;
}
XhtmlDocument placeholderXhtml = PageRenderer.ParsePlaceholderContent(placeholderContent);
if (functionContextContainer != null)
{
bool allFunctionsExecuted;
using (Profiler.Measure($"Evaluating placeholder '{placeholderId}'"))
{
allFunctionsExecuted = PageRenderer.ExecuteCacheableFunctions(placeholderXhtml.Root, functionContextContainer);
}
if (allFunctionsExecuted)
{
using (Profiler.Measure("Normalizing XHTML document"))
{
PageRenderer.NormalizeXhtmlDocument(placeholderXhtml);
}
}
}
PageRenderer.ResolveRelativePaths(placeholderXhtml);
PropertyInfo property = placeholderProperties[placeholderId];
if (!property.ReflectedType.IsInstanceOfType(template))
{
string propertyName = property.Name;
property = template.GetType().GetProperty(property.Name);
Verify.IsNotNull(property, "Failed to find placeholder property '{0}'", propertyName);
}
property.SetValue(template, placeholderXhtml);
}
}
public IHtmlString EvaluateMarkup(XElement element)
{
if (element == null)
{
return(null);
}
var doc = new XElement(element);
PageRenderer.ExecuteEmbeddedFunctions(doc, FunctionContextContainer);
return(new HtmlString(doc.ToString()));
}
internal void Render_Text_Indent()
{
// Arrange
var renderer = new PageRenderer();
renderer.AppendText(PageContentRowFormattingStyle.Indent, "content line");
// Act
var contentText = renderer.ToString();
// Assert
Assert.Equal(" content line", contentText.TrimEnd());
}
public void Template_Shares_Context_With_Layout()
{
string expected = "Begin Layout" +
"Hello" +
"Begin" +
"Hello" +
"End" +
"End Layout";
var layout = TemplatePageTest.CreatePage(v =>
{
v.Write("Begin Layout");
v.Write(v.ViewBag.Title);
v.Write(v.RenderBodyPublic());
v.Write("End Layout");
});
var page = TemplatePageTest.CreatePage(v =>
{
v.Write("Begin");
v.Write(v.ViewBag.Title);
v.Write("End");
});
var lookup = new Mock <IPageLookup>();
lookup.Setup(p => p.GetPage(It.IsAny <string>()))
.Returns(new PageLookupResult(
new PageLookupItem(It.IsAny <string>(), () => layout), new List <PageLookupItem>()));
dynamic viewbag = new ExpandoObject();
viewbag.Title = "Hello";
var context = new PageContext(viewbag);
page.Layout = "_";
page.PageContext = context;
string output;
using (var writer = new StringWriter())
{
page.PageContext.Writer = writer;
var renderer = new PageRenderer(page, lookup.Object);
renderer.RenderAsync(context).Wait();
output = writer.ToString();
}
Assert.Equal(expected, output, StringComparer.Ordinal);
}
private static object EvaluateLazyResult(IEnumerable <XNode> xNodes, FunctionContextContainer context)
{
var resultList = new List <object>();
// Attaching the result to be cached to an XElement, so the cached XObject-s will not be later attached to
// an XDocument and causing a bigger memory leak.
var tempParent = new XElement("t");
foreach (var node in xNodes.Evaluate())
{
node.Remove();
if (node is XElement element)
{
if (element.Name == FunctionXName)
{
var functionTreeNode = (FunctionRuntimeTreeNode)FunctionTreeBuilder.Build(element);
var functionCallResult = functionTreeNode.GetValue(context);
if (functionCallResult != null)
{
if (functionCallResult is XDocument document)
{
functionCallResult = document.Root;
}
resultList.Add(functionCallResult);
if (functionCallResult is XObject || functionCallResult is IEnumerable <XObject> )
{
tempParent.Add(functionCallResult);
}
}
}
else
{
PageRenderer.ExecuteEmbeddedFunctions(element, context);
resultList.Add(element);
tempParent.Add(element);
}
}
else
{
resultList.Add(node);
tempParent.Add(node);
}
}
return(resultList.ToArray());
}
private static object EvaluateLazyResult(object result, FunctionContextContainer context)
{
if (result is XDocument)
{
PageRenderer.ExecuteEmbeddedFunctions((result as XDocument).Root, context);
return(result);
}
if (result is IEnumerable <XNode> )
{
return(EvaluateLazyResult(result as IEnumerable <XNode>, context));
}
return(result);
}
public static void BindPlaceholder(object templateModel, PropertyInfo property, IPagePlaceholderContent content)
{
var rootDocument = PageRenderer.ParsePlaceholderContent(content);
PageRenderer.ResolveRelativePaths(rootDocument);
if (property.ReflectedType != null && !property.ReflectedType.IsInstanceOfType(templateModel))
{
var name = property.Name;
property = templateModel.GetType().GetProperty(property.Name);
Verify.IsNotNull(property, "Failed to find placeholder property '{0}'", new object[] { name });
}
property.SetValue(templateModel, rootDocument);
}
private void editPreviewCodeActivity_ExecuteCode(object sender, EventArgs e)
{
try
{
XhtmlDocument templateDocument = GetTemplateDocumentFromBindings();
IVisualFunction function = this.GetBinding <IVisualFunction>("Function");
Type interfaceType = TypeManager.GetType(function.TypeManagerName);
DataTypeDescriptor typeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(interfaceType);
this.LogMessage(Composite.Core.Logging.LogLevel.Info, DataScopeManager.CurrentDataScope.Name);
FunctionContextContainer fcc = PageRenderer.GetPageRenderFunctionContextContainer();
XhtmlDocument result = RenderingHelper.RenderCompleteDataList(function, templateDocument, typeDescriptor, fcc);
IPage previewPage = DataFacade.BuildNew <IPage>();
previewPage.Id = GetRootPageId();
previewPage.Title = function.Name;
previewPage.DataSourceId.DataScopeIdentifier = DataScopeIdentifier.Administrated;
previewPage.DataSourceId.LocaleScope = LocalizationScopeManager.CurrentLocalizationScope;
previewPage.TemplateId = this.GetBinding <Guid>("PreviewTemplateId");
var pageTemplate = PageTemplateFacade.GetPageTemplate(previewPage.TemplateId);
IPagePlaceholderContent placeHolderContent = DataFacade.BuildNew <IPagePlaceholderContent>();
placeHolderContent.Content = string.Concat((result.Body.Elements().Select(b => b.ToString())).ToArray());
placeHolderContent.PlaceHolderId = pageTemplate.DefaultPlaceholderId;
string output = PagePreviewBuilder.RenderPreview(previewPage, new List <IPagePlaceholderContent> {
placeHolderContent
});
var serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
var webRenderService = serviceContainer.GetService <IFormFlowWebRenderingService>();
webRenderService.SetNewPageOutput(new LiteralControl(output));
}
catch (Exception ex)
{
FlowControllerServicesContainer serviceContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
Control errOutput = new LiteralControl("<pre>" + ex + "</pre>");
var webRenderService = serviceContainer.GetService <IFormFlowWebRenderingService>();
webRenderService.SetNewPageOutput(errOutput);
}
}
static void Main(string[] args)
{
Console.WriteLine("Render pages...");
pRender = new PageRenderer();
////pRender.OnPDFLoaded += PRender_OnPDFLoaded;
Console.WriteLine("Loading PDF");
pRender.LoadPDF("compressed.tracemonkey-pldi-09.pdf");
Console.WriteLine("Getting page images...");
for (int i = 0; i < pRender.PageCount; i++)
{
pRender.RenderPage(i, 1280, 1280).Save("capture_" + (i + 1) + ".png");
}
AddImageToPDF("maxresdefault.jpg");
Console.WriteLine("Done.");
}
/// <exclude />
protected override void CreateChildControls()
{
if (InnerContent == null)
{
ProcessInternalControls();
}
if (InnerContent != null)
{
var functionContextContainer = _functionContextContainer;
if (functionContextContainer == null && this.NamingContainer is UserControlFunction)
{
var containerFunction = this.NamingContainer as UserControlFunction;
functionContextContainer = containerFunction.FunctionContextContainer;
}
if (functionContextContainer == null)
{
functionContextContainer = PageRenderer.GetPageRenderFunctionContextContainer();
}
var controlMapper = (IXElementToControlMapper)functionContextContainer.XEmbedableMapper;
PageRenderer.ExecuteEmbeddedFunctions(InnerContent, functionContextContainer);
var xhmlDocument = new XhtmlDocument(InnerContent);
PageRenderer.NormalizeXhtmlDocument(xhmlDocument);
PageRenderer.ResolveRelativePaths(xhmlDocument);
if (PageRenderer.CurrentPage != null)
{
PageRenderer.ResolvePageFields(xhmlDocument, PageRenderer.CurrentPage);
}
NormalizeAspNetForms(xhmlDocument);
AddNodesAsControls(xhmlDocument.Body.Nodes(), this, controlMapper);
if (Page.Header != null)
{
MergeHeadSection(xhmlDocument, Page.Header, controlMapper);
}
}
base.CreateChildControls();
}
/// <summary>
/// Binds placeholders' content to the related properties on a template definition
/// </summary>
/// <param name="template">The template.</param>
/// <param name="pageContentToRender">The page rendering job.</param>
/// <param name="placeholderProperties">The placeholder properties.</param>
/// <param name="functionContextContainer">The function context container, if not null, nested functions fill be evaluated.</param>
public static void BindPlaceholders(IPageTemplate template,
PageContentToRender pageContentToRender,
IDictionary <string, PropertyInfo> placeholderProperties,
FunctionContextContainer functionContextContainer)
{
Verify.ArgumentNotNull(template, "template");
Verify.ArgumentNotNull(pageContentToRender, "pageContentToRender");
Verify.ArgumentNotNull(placeholderProperties, "placeholderProperties");
foreach (var placeholderContent in pageContentToRender.Contents)
{
string placeholderId = placeholderContent.PlaceHolderId;
if (!placeholderProperties.ContainsKey(placeholderId))
{
continue;
}
XhtmlDocument placeholderXhtml = PageRenderer.ParsePlaceholderContent(placeholderContent);
if (functionContextContainer != null)
{
using (Profiler.Measure("Evaluating placeholder '{0}'".FormatWith(placeholderId)))
{
PageRenderer.ExecuteEmbeddedFunctions(placeholderXhtml.Root, functionContextContainer);
}
PageRenderer.NormalizeXhtmlDocument(placeholderXhtml);
}
PageRenderer.ResolveRelativePaths(placeholderXhtml);
PropertyInfo property = placeholderProperties[placeholderId];
if (!property.ReflectedType.IsAssignableFrom(template.GetType()))
{
string propertyName = property.Name;
property = template.GetType().GetProperty(property.Name);
Verify.IsNotNull(property, "Failed to find placeholder property '{0}'", propertyName);
}
property.SetValue(template, placeholderXhtml, new object[0]);
}
}
internal void Render_Multiple_Text()
{
// Arrange
var renderer = new PageRenderer();
renderer.AppendText(PageContentRowFormattingStyle.None, "content line 1");
renderer.AppendText(PageContentRowFormattingStyle.None, "content line 2");
// Act
var contentText = renderer.ToString();
// Assert
var lines = contentText.ToLines();
Assert.Equal(2, lines.Length);
Assert.Equal("content line 1", lines[0]);
Assert.Equal("content line 2", lines[1]);
}
static void Main(string[] args)
{
var application = new Application();
Forms.Init();
var formsApplicationPage = new FormsApplicationPage();
formsApplicationPage.LoadApplication(new XamarinNeller.App());
Task.Run(() =>
{
Task.Delay(1000).Wait();
application.Dispatcher.InvokeAsync(() =>
{
var window = new Window()
{
Height = 600,
Width = 600
};
var viewPage = new ViewPage()
{
HeightRequest = 500,
WidthRequest = 500
};
var pageRenderer = new PageRenderer();
var mainPage = new MainPage();
pageRenderer.SetElement(viewPage);
//var formsContentLoader = new FormsContentLoader();
//var content = formsContentLoader.LoadContentAsync(window,null, mainPage,new CancellationToken()).Result;
var frameworkElement = pageRenderer.GetNativeElement();
window.Content = frameworkElement;
window.Show();
});
});
application.Run();
}
private void RendererPage(object sender, EventArgs e)
{
var functionContextContainer = PageRenderer.GetPageRenderFunctionContextContainer();
var resultDocument = Render(_job, functionContextContainer);
var controlMapper = (IXElementToControlMapper)functionContextContainer.XEmbedableMapper;
Control control;
using (Profiler.Measure("Rendering the page"))
{
control = PageRenderer.Render(resultDocument, functionContextContainer, controlMapper, _job.Page);
}
using (Profiler.Measure("ASP.NET controls: PagePreInit"))
{
_aspnetPage.Controls.Add(control);
}
}
private void RendererPage(object sender, EventArgs e)
{
if (_aspnetPage.Master != null)
{
// Backward compatibility with CompositeC1Contrib.Renderes.MasterPages package
return;
}
Control renderedPage;
using (Profiler.Measure("Page build up"))
{
renderedPage = PageRenderer.Render(_job.Page, _job.Contents);
}
using (Profiler.Measure("ASP.NET controls: PagePreInit"))
{
_aspnetPage.Controls.Add(renderedPage);
}
}
/// <summary>
/// Runs a template, renders a Layout pages and sections.
/// </summary>
/// <param name="page">Page to run</param>
/// <param name="model">Mode of the page</param>
public string RunTemplate(TemplatePage page, object model)
{
object pageModel = page.PageContext.ModelTypeInfo.CreateTemplateModel(model);
page.SetModel(pageModel);
page.Path = page.PageContext.ExecutingFilePath;
using (var writer = new StringWriter())
{
page.PageContext.Writer = writer;
using (var renderer = new PageRenderer(page, pageLookup))
{
renderer.ViewStartPages.AddRange(page.PageContext.ViewStartPages);
renderer.PreRenderCallbacks.AddRange(Configuration.PreRenderCallbacks);
renderer.RenderAsync(page.PageContext).GetAwaiter().GetResult();
return(writer.ToString());
}
}
}
public async Task <PageInfo> PreparePrevPage()
{
if (_currentPage == null)
{
return(null);
}
string startText = string.Empty;
if (_currentPage != null)
{
startText = _currentPage.StartText;
}
var page = await _pageLoader.GetPreviousPageAsync(_currentPage.FirstTokenID, startText);
if (page == null || page.FirstTokenID < 0)
{
return(null);
}
_prevPage = page;
var bgBuilder = new PageRenderer(_images);
_bookView.PreviousTexts.Clear();
_bookView.PreviousLinks.Clear();
bgBuilder.RenderPageAsync(new RenderPageRequest()
{
Page = page,
Panel = _bookView.GetPrevPagePanel(),
Texts = _bookView.PreviousTexts,
Links = _bookView.PreviousLinks,
Book = _bookModel,
Bookmarks = _bookView.Bookmarks
});
Log.Write("Preparing prev page - @" + page.FirstTokenID + " - " + page.LastTokenID);
return(page);
}
internal void Render_Command_Without_Description()
{
// Arrange
var renderer = new PageRenderer();
renderer.AppendCommand(
PageContentRowFormattingStyle.None,
"command-name",
new PageContentCommandSettings()
);
// Act
var contentText = renderer.ToString();
// Assert
var lines = contentText.ToLines();
Assert.Single(lines);
Assert.Equal("command-name", lines[0]);
}
public XElement RenderDocument(XElement doc)
{
using (Profiler.Measure("Executing C1 functions"))
{
PageRenderer.ExecuteEmbeddedFunctions(doc, FunctionContext);
try
{
var xDoc = new XhtmlDocument(doc);
PageRenderer.NormalizeXhtmlDocument(xDoc);
PageRenderer.ResolveRelativePaths(xDoc);
return(xDoc.Root);
}
catch (ArgumentException)
{
return(doc);
}
}
}
private void OnPrint(object sender, EventArgs arguments){
PrintOperation printing = new PrintOperation();
List<LabelRenderer> labels = new List<LabelRenderer>();
foreach(Model.Item item in Inventory.Items){
Product p = item as Product;
if(p != null && p.LabelMethod == LabelMethod.Print){
labels.Add(new LabelRenderer(item,Inventory.Settings.LabelLayout));
}
}
int labelsPerPage = Inventory.Settings.PageLayout.LabelsPerPage;
int currentLabel = 0;
printing.BeginPrint += delegate (object obj, Gtk.BeginPrintArgs args)
{
printing.NPages = (int)Math.Ceiling( (double)labels.Count/(labelsPerPage));
printing.Unit = Unit.Mm;
};
printing.DrawPage += delegate (object obj, Gtk.DrawPageArgs args)
{
PrintContext context = args.Context;
using(Context cr = context.CairoContext){
// scale down the cairo context
// //context.DpiY,
Pango.Layout layout = context.CreatePangoLayout();
ArrayList pageLabels = new ArrayList();
// it is impossible that we have 0 items, otherwise the page would be empty
do {
pageLabels.Add(labels[currentLabel]);
++currentLabel;
}
while (currentLabel%labelsPerPage != 0 && currentLabel < labels.Count-1);
PageRenderer page = new PageRenderer(pageLabels,Inventory.Settings.PageLayout);
page.Render(cr,layout,0,0,context.Width,context.Height);
}
};
printing.Run (PrintOperationAction.PrintDialog, (Gtk.Window)this.Toplevel);
}
protected override void OnExpose(object o, ExposeEventArgs args)
{
using(Cairo.Context cr = Gdk.CairoHelper.Create(GdkWindow)){
// make the background white with a line around
double x = 0;
double y = 0;
double w = Allocation.Width-settings.SectionWidth;
double h = Allocation.Height-settings.SectionHeight;
Pango.Layout pl = new Pango.Layout(this.PangoContext);
DrawPaper(cr,x,y,w,h);
ArrayList labels = new ArrayList();
for(int i=0;i < settings.PageLayout.LabelsPerPage;++i){
labels.Add( new PseudoLabelRenderer() );
}
GetInnerRegion(ref x,ref y,ref w,ref h);
PageLayout layout = new PageLayout();
layout.LabelRepeatX = settings.PageLayout.LabelRepeatX;
layout.LabelRepeatY = settings.PageLayout.LabelRepeatY;
layout.PaddingX = settings.PageLayout.PaddingX;
layout.PaddingY = settings.PageLayout.PaddingY;
layout.LabelWidth = (w-2*layout.PaddingX-settings.LabelPadding*(layout.LabelRepeatX-1)) / layout.LabelRepeatX;
layout.LabelHeight = (h-2*layout.PaddingY-settings.LabelPadding*(layout.LabelRepeatY-1)) / layout.LabelRepeatY;
PageRenderer pr = new PageRenderer(labels,layout);
pr.Render(cr,pl,x,y,w,h);
//double nn;
//DrawVerticalSectionIndicator(settings.PageLayout.LabelRepeatY.ToString()+"x",cr,pl,x+w+sectionPadding,y,out nn,h);
//DrawHorizontalSectionIndicator(settings.PageLayout.LabelRepeatX.ToString()+"x",cr,pl,x,y+h+sectionPadding,w,out nn);
}
}
