public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
formCollection = collection;
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Install a handler where to change the header and footer in first page
htmlToPdfConverter.PrepareRenderPdfPageEvent += new PrepareRenderPdfPageDelegate(htmlToPdfConverter_PrepareRenderPdfPageEvent);
// Add Document Header
// Enable header in the generated PDF document
htmlToPdfConverter.PdfDocumentOptions.ShowHeader = true;
// Draw document header elements
if (htmlToPdfConverter.PdfDocumentOptions.ShowHeader)
{
DrawHeader(htmlToPdfConverter, true);
}
// Add Document Footer
// Enable footer in the generated PDF document
htmlToPdfConverter.PdfDocumentOptions.ShowFooter = true;
// Draw document footer elements
if (htmlToPdfConverter.PdfDocumentOptions.ShowFooter)
{
DrawFooter(htmlToPdfConverter, true, true);
}
// Convert the HTML page to PDF document in a memory buffer
// The PrepareRenderPdfPageEvent event handler will be invoked for each rendered PDF page
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(collection["urlTextBox"]);
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Change_Header_Footer_Per_Page.pdf";
return(fileResult);
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
formCollection = collection;
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set a handler for AfterRenderPdfPageEvent where to add the stamp in each PDF page over the main content
htmlToPdfConverter.AfterRenderPdfPageEvent += new AfterRenderPdfPageDelegate(htmlToPdfConverter_AfterRenderPdfPageEvent);
try
{
// The buffer to receive the generated PDF document
byte[] outPdfBuffer = null;
if (collection["HtmlPageSource"] == "convertUrlRadioButton")
{
string url = collection["urlTextBox"];
// Convert the HTML page given by an URL to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
else
{
string htmlString = collection["htmlStringTextBox"];
string baseUrl = collection["baseUrlTextBox"];
// Convert a HTML string with a base URL to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlString, baseUrl);
}
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Add_Elements_Over_Main_Content.pdf";
return(fileResult);
}
finally
{
// Uninstall the handler
htmlToPdfConverter.AfterRenderPdfPageEvent -= new AfterRenderPdfPageDelegate(htmlToPdfConverter_AfterRenderPdfPageEvent);
}
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the CSS selectors of the HTML elements before which to insert page breaks
htmlToPdfConverter.PdfDocumentOptions.PageBreakBeforeHtmlElementsSelectors = new string[] { htmlElementsBeforeSelectorTextBox.Text };
// Set the CSS selectors of the HTML elements after which to insert page breaks
htmlToPdfConverter.PdfDocumentOptions.PageBreakAfterHtmlElementsSelectors = new string[] { htmlElementsAfterSelectorTextBox.Text };
byte[] outPdfBuffer = null;
if (convertHtmlRadioButton.Checked)
{
string htmlWithForm = htmlStringTextBox.Text;
string baseUrl = baseUrlTextBox.Text;
// Convert the HTML string to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlWithForm, baseUrl);
}
else
{
string url = urlTextBox.Text;
// Convert the HTML page to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Insert_Page_Breaks_Before_After_HTML_Elements_Using_API.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Get the server IP and port
String serverIP = textBoxServerIP.Text;
uint serverPort = uint.Parse(textBoxServerPort.Text);
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter(serverIP, serverPort);
// Set optional service password
if (textBoxServicePassword.Text.Length > 0)
{
htmlToPdfConverter.ServicePassword = textBoxServicePassword.Text;
}
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the PDF color space
// By default the RGB color space is used
if (grayScaleRadioButton.Checked)
{
htmlToPdfConverter.PdfDocumentOptions.ColorSpace = ColorSpace.Gray;
}
else if (cmykRadioButton.Checked)
{
htmlToPdfConverter.PdfDocumentOptions.ColorSpace = ColorSpace.CMYK;
}
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(urlTextBox.Text);
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=PDF_Color_Space.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Get the server IP and port
String serverIP = textBoxServerIP.Text;
uint serverPort = uint.Parse(textBoxServerPort.Text);
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter(serverIP, serverPort);
// Set optional service password
if (textBoxServicePassword.Text.Length > 0)
{
htmlToPdfConverter.ServicePassword = textBoxServicePassword.Text;
}
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Auto Create a hierarchy of bookmarks from H1 to H6 tags found in HTML
if (autoBookmarksCheckBox.Checked)
{
// Enable the creation of a hierarchy of bookmarks from H1 to H6 tags
htmlToPdfConverter.PdfBookmarkOptions.AutoBookmarksEnabled = true;
// Display the bookmarks panel in PDF viewer when the generated PDF is opened
htmlToPdfConverter.PdfViewerPreferences.PageMode = ViewerPageMode.UseOutlines;
}
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(urlTextBox.Text);
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Auto_Create_Hierarchical_Bookmarks.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Get the server IP and port
String serverIP = textBoxServerIP.Text;
uint serverPort = uint.Parse(textBoxServerPort.Text);
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter(serverIP, serverPort);
// Set optional service password
if (textBoxServicePassword.Text.Length > 0)
{
htmlToPdfConverter.ServicePassword = textBoxServicePassword.Text;
}
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the JPEG Compression Level
// A higher compression level produces smaller PDF documents but lower quality images in PDF
// Leave it not set for a default compression level
htmlToPdfConverter.PdfDocumentOptions.JpegCompressionLevel = int.Parse(jpegCompressionLevelTextBox.Text);
// Set images scaling before rendering to PDF
// This option enables the converter to scale the images used in HTML down to their display size in HTML before rendering them in PDF.
// This can lead to smaller memory consumption during conversion and to a smaller PDF document size but the images quality in PDF can be lower
htmlToPdfConverter.PdfDocumentOptions.ImagesScalingEnabled = imagesScalingCheckBox.Checked;
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(urlTextBox.Text);
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Images_Scaling_and_JPEG_Compression.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the PDF file to be inserted before the table of contents
string pdfFileBefore = m_hostingEnvironment.ContentRootPath + "/wwwroot" + "/DemoAppFiles/Input/PDF_Files/Merge_Before_Conversion.pdf";
htmlToPdfConverter.PdfDocumentOptions.AddStartDocument(pdfFileBefore);
// Enable the creation of a table of contents from H1 to H6 tags found in HTML
htmlToPdfConverter.TableOfContentsOptions.AutoTocItemsEnabled = collection["autoTableOfContentsCheckBox"].Count > 0;
// Optionally set the table of contents title
htmlToPdfConverter.TableOfContentsOptions.Title = "Table of Contents";
// Optionally set the title style using CSS sttributes
htmlToPdfConverter.TableOfContentsOptions.TitleStyle = "color:navy; font-family:'Times New Roman'; font-size:28px; font-weight:normal";
// Optionally set the style of level 1 items in table of contents
string level1TextStyle = "color:black; font-family:'Times New Roman'; font-size:20px; font-weight:normal; font-style:normal; background-color:#F0F0F0";
htmlToPdfConverter.TableOfContentsOptions.SetItemStyle(1, level1TextStyle);
// Optionally set the page numbers style of level 1 items in table of contents
string level1PageNumberStyle = "color:black; padding-right:3px; background-color:#F0F0F0; font-size:14px; font-weight:bold";
htmlToPdfConverter.TableOfContentsOptions.SetPageNumberStyle(1, level1PageNumberStyle);
// The URL to convert
string url = collection["urlTextBox"];
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Insert_PDF_Before_Table_of_Contents.pdf";
return(fileResult);
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Add custom HTTP cookies
if (collection["cookie1NameTextBox"][0].Length > 0 && collection["cookie1ValueTextBox"][0].Length > 0)
{
htmlToPdfConverter.HttpRequestCookies.Add(collection["cookie1NameTextBox"], collection["cookie1ValueTextBox"]);
}
if (collection["cookie2NameTextBox"][0].Length > 0 && collection["cookie2ValueTextBox"][0].Length > 0)
{
htmlToPdfConverter.HttpRequestCookies.Add(collection["cookie2NameTextBox"], collection["cookie2ValueTextBox"]);
}
if (collection["cookie3NameTextBox"][0].Length > 0 && collection["cookie3ValueTextBox"][0].Length > 0)
{
htmlToPdfConverter.HttpRequestCookies.Add(collection["cookie3NameTextBox"], collection["cookie3ValueTextBox"]);
}
if (collection["cookie4NameTextBox"][0].Length > 0 && collection["cookie4ValueTextBox"][0].Length > 0)
{
htmlToPdfConverter.HttpRequestCookies.Add(collection["cookie4NameTextBox"], collection["cookie4ValueTextBox"]);
}
if (collection["cookie5NameTextBox"][0].Length > 0 && collection["cookie5ValueTextBox"][0].Length > 0)
{
htmlToPdfConverter.HttpRequestCookies.Add(collection["cookie5NameTextBox"], collection["cookie5ValueTextBox"]);
}
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(collection["urlTextBox"]);
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "HTTP_Cookies.pdf";
return(fileResult);
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set if the fonts are embedded in the generated PDF document
// Leave it not set to embed the fonts in the generated PDF document
htmlToPdfConverter.PdfDocumentOptions.EmbedFonts = embedFontsCheckBox.Checked;
// The buffer to receive the generated PDF document
byte[] outPdfBuffer = null;
if (convertUrlRadioButton.Checked)
{
string url = urlTextBox.Text;
// Convert the HTML page given by an URL to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
else
{
string htmlString = htmlStringTextBox.Text;
string baseUrl = baseUrlTextBox.Text;
// Convert a HTML string with a base URL to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlString, baseUrl);
}
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Embed_Fonts_in_PDF.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Enable the creation of a table of contents from H1 to H6 tags found in HTML
htmlToPdfConverter.TableOfContentsOptions.AutoTocItemsEnabled = autoTableOfContentsCheckBox.Checked;
// Optionally set the table of contents title
htmlToPdfConverter.TableOfContentsOptions.Title = "Table of Contents";
// Optionally set the title style using CSS sttributes
htmlToPdfConverter.TableOfContentsOptions.TitleStyle = "color:navy; font-family:'Times New Roman'; font-size:28px; font-weight:normal";
// Optionally set the style of level 1 items in table of contents
string level1TextStyle = "color:black; font-family:'Times New Roman'; font-size:20px; font-weight:normal; font-style:normal; background-color:#F0F0F0";
htmlToPdfConverter.TableOfContentsOptions.SetItemStyle(1, level1TextStyle);
// Optionally set the page numbers style of level 1 items in table of contents
string level1PageNumberStyle = "color:black; padding-right:3px; background-color:#F0F0F0; font-size:14px; font-weight:bold";
htmlToPdfConverter.TableOfContentsOptions.SetPageNumberStyle(1, level1PageNumberStyle);
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(urlTextBox.Text);
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Auto_Create_Table_of_Contents.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the media type for which to render HTML to PDF
htmlToPdfConverter.MediaType = printMediaTypeRadioButton.Checked ? "print" : "screen";
byte[] outPdfBuffer = null;
if (convertHtmlRadioButton.Checked)
{
string htmlWithForm = htmlStringTextBox.Text;
string baseUrl = baseUrlTextBox.Text;
// Convert a HTML string to a PDF document for the selected media type
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlWithForm, baseUrl);
}
else
{
string url = urlTextBox.Text;
// Convert the HTML page to a PDF document for the selected media type
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Select_Screen_or_Print_Media_Type.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Display the bookmarks panel in PDF viewer when the generated PDF is opened
htmlToPdfConverter.PdfViewerPreferences.PageMode = ViewerPageMode.UseOutlines;
byte[] outPdfBuffer = null;
if (convertHtmlRadioButton.Checked)
{
string htmlWithBookmarkAttributes = htmlStringTextBox.Text;
string baseUrl = baseUrlTextBox.Text;
// Convert a HTML string with bookmark attributes to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlWithBookmarkAttributes, baseUrl);
}
else
{
string url = urlTextBox.Text;
// Convert a HTML page with bookmark attributes to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Select_in_HTML_Elements_to_Bookmark.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
/// <summary>
/// Generar un pdf a partir de una url para la carta e info de adtrends
/// </summary>
/// <param name="url"></param>
/// <param name="proposalId"></param>
/// <param name="mkId"></param>
/// <param name="type"></param>
/// <returns></returns>
public string GeneratePdfFromString(string html, string NombreArchivo, string LocalRoot, string RemoteRoot)
{
string debugger = string.Empty;
string fileName = NombreArchivo + DateTime.Now.Millisecond.ToString();
string returnURL = LocalRoot + "PDFs\\" + "\\" + fileName + ".pdf";
try
{
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "11lKWElYQEpNWElJVkhYS0lWSUpWQUFBQQ==";
// Set HTML Viewer width in pixels which is the equivalent in converter of the browser window width
htmlToPdfConverter.HtmlViewerWidth = 800;
// Set PDF page size which can be a predefined size like A4 or a custom size in points
// Leave it not set to have a default A4 PDF page
htmlToPdfConverter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
// Set PDF page orientation to Portrait or Landscape
// Leave it not set to have a default Portrait orientation for PDF page
htmlToPdfConverter.PdfDocumentOptions.PdfPageOrientation = PdfPageOrientation.Portrait;
htmlToPdfConverter.PdfDocumentOptions.AvoidImageBreak = true;
htmlToPdfConverter.PdfDocumentOptions.AvoidTextBreak = true;
try { File.Delete(returnURL); }
catch { }
string htmlUrl = returnURL.Replace(".pdf", ".html");
try { File.Delete(htmlUrl); }
catch { }
File.WriteAllText(htmlUrl, html);
string lv_url = RemoteRoot + "/PDFs/" + fileName + ".html";
byte[] downloadBytes = htmlToPdfConverter.ConvertUrl(lv_url);
FileStream fs = new FileStream(returnURL, FileMode.Create);
fs.Write(downloadBytes, 0, downloadBytes.Length);
fs.Flush();
fs.Close();
fileName = returnURL.Replace(".html", ".pdf");
}
catch (Exception e)
{
}
return(fileName);
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the PDF Viewer Preferences
// Set page layout to continuous one column, single page, two column left, two column right
htmlToPdfConverter.PdfViewerPreferences.PageLayout = SelectedPageLayout();
// Set page mode to default, display bookmarks, display thumbnails, display attachments
htmlToPdfConverter.PdfViewerPreferences.PageMode = SelectedPageMode();
// Hide the viewer menu
htmlToPdfConverter.PdfViewerPreferences.HideMenuBar = hideMenuBarCheckBox.Checked;
// Hide the viewer toolbar
htmlToPdfConverter.PdfViewerPreferences.HideToolbar = hideToolbarCheckBox.Checked;
// Hide scroll bars and navigation controls
htmlToPdfConverter.PdfViewerPreferences.HideWindowUI = hideWindowUICheckBox.Checked;
// Display the document title in viewer title bar
htmlToPdfConverter.PdfViewerPreferences.DisplayDocTitle = displayDocTitleCheckBox.Checked;
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(urlTextBox.Text);
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Set_PDF_Viewer_Preferences.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set if the HTML tables headers are repeated in PDF
// You can also disable the header repeating if you add style="display: table-row-group" to thead tag in HTML
htmlToPdfConverter.PdfDocumentOptions.TableHeaderRepeatEnabled = collection["repeatHtmlTableHeaderCheckBox"].Count > 0;
// Set if the HTML tables footers are repeated in PDF
// You can also disable the footer repeating if you add style="display: table-row-group" to tfoot tag in HTML
htmlToPdfConverter.PdfDocumentOptions.TableFooterRepeatEnabled = collection["repeatHtmlTableFooterCheckBox"].Count > 0;
byte[] outPdfBuffer = null;
if (collection["HtmlPageSource"] == "convertHtmlRadioButton")
{
string htmlWithForm = collection["htmlStringTextBox"];
string baseUrl = collection["baseUrlTextBox"];
// Convert a HTML string with repetead header and footer to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlWithForm, baseUrl);
}
else
{
string url = collection["urlTextBox"];
// Convert the HTML page with repetead header and footer to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Repeat_HTML_Table_Header_Footer.pdf";
return(fileResult);
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Get the server IP and port
String serverIP = textBoxServerIP.Text;
uint serverPort = uint.Parse(textBoxServerPort.Text);
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter(serverIP, serverPort);
// Set optional service password
if (textBoxServicePassword.Text.Length > 0)
{
htmlToPdfConverter.ServicePassword = textBoxServicePassword.Text;
}
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Enable extensions including the Flash support
// The converter does not have a built-in Flash player and it uses the installed Flash plugin
// for Google Chrome or Mozilla Firefox
htmlToPdfConverter.ExtensionsEnabled = extensionsEnabledCheckBox.Checked;
// Set an adddional delay in seconds to wait for Flash to run
// Set this property to 0 if you want to start conversion immediately
htmlToPdfConverter.ConversionDelay = int.Parse(conversionDelayTextBox.Text);
// Convert the HTML page with Flash to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(urlTextBox.Text);
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Flash_to_PDF.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set proxy type
// when converting HTML pages from HTTP addresses use the Http proxy type
// when converting HTML pages from HTTPS addresses use Socks5 proxy type and make sure the proxy server
// is also configured to use SOCKS5 protocol
htmlToPdfConverter.ProxyOptions.Type = SelectedProxyType(collection["proxyTypeDropDownList"]);
// Set proxy hostname and port number
// Hostname and port number are required when the proxy type is set to something different from None value
htmlToPdfConverter.ProxyOptions.HostName = collection["hostNameTextBox"];
htmlToPdfConverter.ProxyOptions.PortNumber = int.Parse(collection["portNumberTextBox"]);
// Optionally set proxy username and password if they are required by proxy server
htmlToPdfConverter.ProxyOptions.Username = collection["usernameTextBox"];
htmlToPdfConverter.ProxyOptions.Password = collection["passwordTextBox"];
// Optionally set a list of hosts to be accessed directly without a proxy
if (collection["bypassedHostTextBox"][0].Length > 0)
{
htmlToPdfConverter.ProxyOptions.BypassedHosts = new string[] { collection["bypassedHostTextBox"] }
}
;
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(collection["urlTextBox"]);
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Proxy_Options.pdf";
return(fileResult);
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the CSS selectors of the HTML elements before which to insert page breaks
htmlToPdfConverter.PdfDocumentOptions.PageBreakBeforeHtmlElementsSelectors = new string[] { collection["htmlElementsBeforeSelectorTextBox"] };
// Set the CSS selectors of the HTML elements after which to insert page breaks
htmlToPdfConverter.PdfDocumentOptions.PageBreakAfterHtmlElementsSelectors = new string[] { collection["htmlElementsAfterSelectorTextBox"] };
byte[] outPdfBuffer = null;
if (collection["HtmlPageSource"] == "convertHtmlRadioButton")
{
string htmlWithForm = collection["htmlStringTextBox"];
string baseUrl = collection["baseUrlTextBox"];
// Convert the HTML string to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlWithForm, baseUrl);
}
else
{
string url = collection["urlTextBox"];
// Convert the HTML page to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Insert_Page_Breaks_Before_After_HTML_Elements_Using_API.pdf";
return(fileResult);
}
// POST api/values
public void GeneratePdf([FromBody] PdfUrl urls)
{
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
htmlToPdfConverter.PrepareRenderPdfPageEvent += new PrepareRenderPdfPageDelegate(htmlToPdfConverter_PrepareRenderPdfPageEvent);
htmlToPdfConverter.TableOfContentsOptions.AutoTocItemsEnabled = true;
htmlToPdfConverter.TableOfContentsOptions.Title = "Table of Contents";
string backgroundColor = "background-color:white;";
string level1TextStyle = "color:black; font-family:'Times New Roman'; font-size:20px; font-weight:bold; font-style:normal;";
htmlToPdfConverter.TableOfContentsOptions.SetItemStyle(1, level1TextStyle);
for (int i = 1; i <= 6; i++)
{
htmlToPdfConverter.TableOfContentsOptions.SetItemStyle(i, backgroundColor);
htmlToPdfConverter.TableOfContentsOptions.SetPageNumberStyle(i, backgroundColor);
}
htmlToPdfConverter.PdfDocumentOptions.PageBreakBeforeHtmlElementsSelectors = new string[] { ".break-before" };
htmlToPdfConverter.PdfDocumentOptions.PageBreakAfterHtmlElementsSelectors = new string[] { ".break-after" };
htmlToPdfConverter.PdfDocumentOptions.TopMargin = 30;
if (!urls.HeaderUrl.IsEmpty())
{
htmlToPdfConverter.PdfDocumentOptions.ShowHeader = true;
DrawHeader(htmlToPdfConverter, urls);
}
if (!urls.FooterUrl.IsEmpty())
{
htmlToPdfConverter.PdfDocumentOptions.ShowFooter = true;
DrawFooter(htmlToPdfConverter, urls);
}
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(urls.ContentUrl);
HttpContext.Current.Response.AddHeader("Content-Type", "application/pdf");
HttpContext.Current.Response.AddHeader("Content-Disposition", string.Format("{0}; filename=Getting_Started.pdf; size={1}", "attachment", outPdfBuffer.Length.ToString()));
HttpContext.Current.Response.BinaryWrite(outPdfBuffer);
HttpContext.Current.Response.End();
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set if the fonts are embedded in the generated PDF document
// Leave it not set to embed the fonts in the generated PDF document
htmlToPdfConverter.PdfDocumentOptions.EmbedFonts = collection["embedFontsCheckBox"].Count > 0;
// The buffer to receive the generated PDF document
byte[] outPdfBuffer = null;
if (collection["HtmlPageSource"] == "convertUrlRadioButton")
{
string url = collection["urlTextBox"];
// Convert the HTML page given by an URL to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
else
{
string htmlString = collection["htmlStringTextBox"];
string baseUrl = collection["baseUrlTextBox"];
// Convert a HTML string with a base URL to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlString, baseUrl);
}
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Embed_Fonts_in_PDF.pdf";
return(fileResult);
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the PDF file to be inserted before conversion result
string pdfFileBefore = Server.MapPath("~/DemoAppFiles/Input/PDF_Files/Merge_Before_Conversion.pdf");
htmlToPdfConverter.PdfDocumentOptions.AddStartDocument(pdfFileBefore);
// Set the PDF file to be added after conversion result
string pdfFileAfter = Server.MapPath("~/DemoAppFiles/Input/PDF_Files/Merge_After_Conversion.pdf");
htmlToPdfConverter.PdfDocumentOptions.AddEndDocument(pdfFileAfter);
// The URL to convert
string url = urlTextBox.Text;
// Convert the HTML page to a PDF document and add the external PDF documents
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Merge_HTML_with_Existing_PDF.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
public void toPDF()
{
/*var htmlContent = String.Format("<body>Hello world: {0}</body>",
* DateTime.Now);
* var pdfBytes = new NReco.PdfGenerator.HtmlToPdfConverter().GeneratePdfFromFile("http://localhost:58499/Korisnici/Narudzbe", null);
* Response.ContentType = "application/pdf";
* Response.ContentEncoding = System.Text.Encoding.UTF8;
* Response.AddHeader("Content-Disposition", "Inline; filename=TEST.pdf");
* Response.BinaryWrite(pdfBytes);
* Response.Flush();
* Response.End();*/
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Select the HTML element to convert
string htmlElementSelector = ".services";
htmlToPdfConverter.RenderedHtmlElementSelector = htmlElementSelector;
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl("http://telnet20170525114130.azurewebsites.net/Korisnici/Narudzbe");
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Narudzbe.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Display the bookmarks panel in PDF viewer when the generated PDF is opened
htmlToPdfConverter.PdfViewerPreferences.PageMode = ViewerPageMode.UseOutlines;
byte[] outPdfBuffer = null;
if (collection["HtmlPageSource"] == "convertHtmlRadioButton")
{
string htmlWithBookmarkAttributes = collection["htmlStringTextBox"];
string baseUrl = collection["baseUrlTextBox"];
// Convert a HTML string with bookmark attributes to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlWithBookmarkAttributes, baseUrl);
}
else
{
string url = collection["urlTextBox"];
// Convert a HTML page with bookmark attributes to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Select_in_HTML_Elements_to_Bookmark.pdf";
return(fileResult);
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the media type for which to render HTML to PDF
htmlToPdfConverter.MediaType = collection["MediaType"] == "printMediaTypeRadioButton" ? "print" : "screen";
byte[] outPdfBuffer = null;
if (collection["HtmlPageSource"] == "convertHtmlRadioButton")
{
string htmlWithForm = collection["htmlStringTextBox"];
string baseUrl = collection["baseUrlTextBox"];
// Convert a HTML string to a PDF document for the selected media type
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlWithForm, baseUrl);
}
else
{
string url = collection["urlTextBox"];
// Convert the HTML page to a PDF document for the selected media type
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Select_Screen_or_Print_Media_Type.pdf";
return(fileResult);
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the PDF Standard
// By default the full PDF standard is used
if (pdfARadioButton.Checked)
{
htmlToPdfConverter.PdfDocumentOptions.PdfStandardSubset = PdfStandardSubset.Pdf_A_1b;
}
else if (pdfXRadioButton.Checked)
{
htmlToPdfConverter.PdfDocumentOptions.PdfStandardSubset = PdfStandardSubset.Pdf_X_1a;
}
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(urlTextBox.Text);
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=PDF_A_PDF_X.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the PDF Viewer Preferences
// Set page layout to continuous one column, single page, two column left, two column right
htmlToPdfConverter.PdfViewerPreferences.PageLayout = SelectedPageLayout(collection["pageLayoutComboBox"]);
// Set page mode to default, display bookmarks, display thumbnails, display attachments
htmlToPdfConverter.PdfViewerPreferences.PageMode = SelectedPageMode(collection["pageModeComboBox"]);
// Hide the viewer menu
htmlToPdfConverter.PdfViewerPreferences.HideMenuBar = collection["hideMenuBarCheckBox"].Count > 0;
// Hide the viewer toolbar
htmlToPdfConverter.PdfViewerPreferences.HideToolbar = collection["hideToolbarCheckBox"].Count > 0;
// Hide scroll bars and navigation controls
htmlToPdfConverter.PdfViewerPreferences.HideWindowUI = collection["hideWindowUICheckBox"].Count > 0;
// Display the document title in viewer title bar
htmlToPdfConverter.PdfViewerPreferences.DisplayDocTitle = collection["displayDocTitleCheckBox"].Count > 0;
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(collection["urlTextBox"]);
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Set_PDF_Viewer_Preferences.pdf";
return(fileResult);
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
byte[] outPdfBuffer = null;
if (collection["HtmlPageSource"] == "convertHtmlRadioButton")
{
string htmlWithInternalLinksAttributes = collection["htmlStringTextBox"];
string baseUrl = collection["baseUrlTextBox"];
// Convert a HTML string with URI links to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertHtml(htmlWithInternalLinksAttributes, baseUrl);
}
else
{
string url = collection["urlTextBox"];
// Convert a HTML page with URI links to a PDF document in a memory buffer
outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
}
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Custom_URI_Links.pdf";
return(fileResult);
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Convert the HTML page with Web Fonts to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(collection["urlTextBox"]);
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Web_Fonts_to_PDF.pdf";
return(fileResult);
}
protected void convertToPdfButton_Click(object sender, EventArgs e)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Select the HTML elements for which to retrieve location and other information from HTML document
if (hideSelectedElementsCheckBox.Checked)
{
htmlToPdfConverter.HiddenHtmlElementsSelectors = new string[] { htmlElementsSelectorTextBox.Text }
}
;
// Convert the HTML page to a PDF document in a memory buffer
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(urlTextBox.Text);
// Send the PDF as response to browser
// Set response content type
Response.AddHeader("Content-Type", "application/pdf");
// Instruct the browser to open the PDF file as an attachment or inline
Response.AddHeader("Content-Disposition", String.Format("attachment; filename=Select_in_API_HTML_Elements_to_Hide.pdf; size={0}", outPdfBuffer.Length.ToString()));
// Write the PDF document buffer to HTTP response
Response.BinaryWrite(outPdfBuffer);
// End the HTTP response and stop the current page processing
Response.End();
}
public ActionResult ConvertHtmlToPdf(IFormCollection collection)
{
// Create a HTML to PDF converter object with default settings
HtmlToPdfConverter htmlToPdfConverter = new HtmlToPdfConverter();
// Set license key received after purchase to use the converter in licensed mode
// Leave it not set to use the converter in demo mode
htmlToPdfConverter.LicenseKey = "4W9+bn19bn5ue2B+bn1/YH98YHd3d3c=";
// Set an adddional delay in seconds to wait for JavaScript or AJAX calls after page load completed
// Set this property to 0 if you don't need to wait for such asynchcronous operations to finish
htmlToPdfConverter.ConversionDelay = 2;
// Set the PDF file to be inserted before conversion result
string pdfFileBefore = m_hostingEnvironment.ContentRootPath + "/wwwroot" + "/DemoAppFiles/Input/PDF_Files/Merge_Before_Conversion.pdf";
htmlToPdfConverter.PdfDocumentOptions.AddStartDocument(pdfFileBefore);
// Set the PDF file to be added after conversion result
string pdfFileAfter = m_hostingEnvironment.ContentRootPath + "/wwwroot" + "/DemoAppFiles/Input/PDF_Files/Merge_After_Conversion.pdf";
htmlToPdfConverter.PdfDocumentOptions.AddEndDocument(pdfFileAfter);
// The URL to convert
string url = collection["urlTextBox"];
// Convert the HTML page to a PDF document and add the external PDF documents
byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrl(url);
// Send the PDF file to browser
FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
fileResult.FileDownloadName = "Merge_HTML_with_Existing_PDF.pdf";
return(fileResult);
}
