Options de rendu

Les options de rendu vous donnent un contrôle supplémentaire sur le périphérique de rendu. Chaque périphérique de rendu – PdfDevice, XpsDevice, DocDevice, et ImageDevice possède son propre ensemble d’options implémentées avec les classes PdfRenderingOptions, XpsRenderingOptions, DocRenderingOptions, et ImageRenderingOptions respectivement. Vous pouvez modifier la taille de la page, configurer les marges et les couleurs, définir un mot de passe de sécurité dans le cas d’un périphérique PDF, etc. La personnalisation des options de rendu est essentielle pour obtenir le document de sortie souhaité. Par exemple, vous pouvez réduire la taille du fichier en ajustant la qualité et la résolution de l’image ou améliorer la lisibilité en définissant les marges de la page et le formatage du texte.

Dans cet article, nous décrivons dans des exemples C# comment utiliser les options de rendu pour personnaliser le processus de rendu de HTML vers PDF, XPS, DOCX et Images. Un dispositif de rendu prend un objet d’options en paramètre et représente un document de sortie. Pour en savoir plus, veuillez lire l’article Dispositif de rendu.

Voici une démonstration de l’utilisation de PdfRenderingOptions pour personnaliser la taille de la page lors de la conversion de HTML en PDF :

// Render HTML to PDF in C# with custom page size

string code = @"<span>Hello, World!!</span>";

// Initialize an HTML document from HTML code
using HTMLDocument document = new HTMLDocument(code, ".");

// Create an instance of PdfRenderingOptions and set a custom page size
PdfRenderingOptions options = new PdfRenderingOptions()
{
    PageSetup =
        {
            AnyPage = new Page(new Size(Length.FromInches(4),Length.FromInches(2)))
        }
};

// Prepare a path to save the converted file 
string savePath = Path.Combine(OutputDir, "file-with-custom-page-size.pdf");

// Create an instance of the PdfDevice and specify the options and output file to render
using PdfDevice device = new PdfDevice(options, savePath);

// Render HTML to PDF
document.RenderTo(device);

Options générales

L’espace de noms Aspose.Html.Rendering comprend de nombreux objets de rendu et des classes d’options de bas niveau appropriées responsables du rendu des documents dans l’implémentation IDevice. Les classes RenderingOptions et CssOptions représentent les options de rendu ou, en d’autres termes, les options de rendu générales. Ces options sont valables pour tous les dispositifs de rendu et tous les processus de rendu, de HTML à PDF, XPS, DOCX et Images :

Property	Description
PageSetup	This property gets a page setup object and uses it for configuration output page-set.
Css	Gets a CssOptions object which is used for configuration of CSS properties processing.
BackgroundColor	This property sets the color that will fill the background of every page. By default, this property is Transparent.
HorizontalResolution	Sets horizontal resolution for output images in pixels per inch. The default value is 300 dpi.
VerticalResolution	Sets vertical resolution for output images in pixels per inch. The default value is 300 dpi.
MediaType	Sets MediaType which will be used for media queries resolution during rendering. Default value is Print.

Résolution horizontale et verticale

Dans l’exemple suivant, nous montrerons comment nous pouvons contrôler la résolution du fichier image résultant, ce qui affecte en fin de compte sa taille et sa qualité :

// Render HTML to PNG with custom resolution using C#

// Prepare a path to a source HTML file
string documentPath = Path.Combine(DataDir, "spring.html");

// Create an instance of HTML document
using HTMLDocument document = new HTMLDocument(documentPath);

// Prepare path to save output file 
string savePath1 = Path.Combine(OutputDir, "output_resolution_50.png");
string savePath2 = Path.Combine(OutputDir, "output_resolution_300.png");

// Create options for low-resolution screens
    ImageRenderingOptions options1 = new ImageRenderingOptions()
    {
        HorizontalResolution = 50,
        VerticalResolution = 50
    };

// Create an instance of Image device
using ImageDevice device1 = new ImageDevice(options1, savePath1);

// Render HTML to PNG
document.RenderTo(device1);


// Create options for high-resolution screens
ImageRenderingOptions options2 = new ImageRenderingOptions()
{
    HorizontalResolution = 300,
    VerticalResolution = 300
};

// Create an instance of Image device
using ImageDevice device2 = new ImageDevice(options2, savePath2);

// Render HTML to PNG
document.RenderTo(device2);

L’image suivante montre le résultat du rendu du fichier spring.html avec des résolutions de 50 dpi et 300 dpi :

Type de média CSS

CSS le type de support est une caractéristique importante qui spécifie comment un document sera présenté sur différents supports : à l’écran, sur papier, avec un appareil braille, etc. Il existe plusieurs façons de spécifier le type de support d’une feuille de style, par le biais de feuilles de style liées ou d’inlining :

Linked Style Sheet

 <link rel="stylesheet" type="text/css" media="print" href="style.css">

Inline Style Sheet

<style type="text/css">
@media print {
  body{ color: #000000; }
}
</style>

L’API Aspose.HTML prend en charge cette fonctionnalité, de sorte que vous pouvez convertir des documents HTML tels qu’ils apparaissent à l’écran ou à l’impression en appliquant les types de médias et les feuilles de style correspondants. L’exemple suivant montre comment configurer le type de média :

// Create an option class
var options = new PdfRenderingOptions();

// Set the 'screen' media-type
options.Css.MediaType = MediaType.Screen;

Veuillez noter que la valeur par défaut de CssOptions.MediaType est Print. Cela signifie que le document sera converti en appliquant les feuilles de style liées au périphérique d’impression et qu’il aura l’apparence du papier (vous pouvez utiliser l’aperçu avant impression de votre navigateur pour voir la différence). Par conséquent, si vous souhaitez que le document ait la même apparence qu’à l’écran, vous devez utiliser MediaType.Screen.

Couleur de fond

La propriété BackgroundColor est utilisée pour définir la couleur d’arrière-plan du document de sortie lors du rendu de fichiers HTML aux formats PDF, XPS, DOCX ou image. Par défaut, la couleur d’arrière-plan est transparente. Cependant, vous pouvez définir cette propriété sur une couleur spécifique en utilisant la classe RenderingOptions.

// Render HTML to PDF with custom background color using C#

// Prepare path to a source HTML file
string documentPath = Path.Combine(DataDir, "spring.html");

// Prepare a path to save the converted file 
string savePath = Path.Combine(OutputDir, "spring.pdf");

// Create an instance of HTML document
using HTMLDocument document = new HTMLDocument(documentPath);

// Initialize options with 'Azure' as a background-color
PdfRenderingOptions options = new PdfRenderingOptions()
{
    BackgroundColor = System.Drawing.Color.Azure
};

// Create an instance of PDF device
using PdfDevice device = new PdfDevice(options, savePath);

// Render HTML to PDF
document.RenderTo(device);

Mise en page

La mise en page est un ensemble de paramètres qui déterminent la disposition d’une page imprimée. Ces paramètres vont de la taille de la page, des marges et du redimensionnement automatique aux règles de priorité @page. Vous pouvez facilement définir une mise en page individuelle pour chaque page à l’aide de cet ensemble de paramètres.

L’exemple suivant montre comment créer un document PDF avec des tailles de page différentes pour les pages de gauche et de droite (voir la visualisation du résultat dans la figure (a) ci-dessous) :

// Render HTML to PDF with custom page size using C#

// Prepare HTML code
string code = @"<style>div { page-break-after: always; }</style>
<div>First Page</div>
<div>Second Page</div>
<div>Third Page</div>
<div>Fourth Page</div>";

// Initialize an HTML document from the HTML code
using HTMLDocument document = new HTMLDocument(code, ".");

// Create the instance of Rendering Options and set a custom page size
PdfRenderingOptions options = new PdfRenderingOptions();
options.PageSetup.SetLeftRightPage(
    new Page(new Size(400, 150)),
    new Page(new Size(400, 50))
);

// Prepare a path to save the converted file 
string savePath = Path.Combine(OutputDir, "output-custom-page-size.pdf");

// Create the PDF Device and specify options and output file
using PdfDevice device = new PdfDevice(options, savePath);

// Render HTML to PDF
document.RenderTo(device);

Dans certains cas, le contenu de la page HTML peut être plus large que la taille de la page définie dans les options. Si vous ne voulez pas couper le contenu de la page, vous pouvez essayer la propriété AdjustToWidestPage de la classe PageSetup. L’exemple suivant montre comment adapter la taille de la page au contenu (voir la visualisation du résultat dans la figure (b) ci-dessous) :

// Render HTML to PDF and adjust to the widest page with C#

// Prepare HTML code
string code = @"<style>
    div { page-break-after: always; }
</style>
<div style='border: 1px solid red; width: 300px'>First Page</div>
<div style='border: 1px solid red; width: 500px'>Second Page</div>";

// Initialize an HTML document from the HTML code
using HTMLDocument document = new HTMLDocument(code, ".");

// Create the instance of Rendering Options and set a custom page-size
PdfRenderingOptions options = new PdfRenderingOptions();
options.PageSetup.AnyPage = new Page(new Size(400, 200));

// Enable auto-adjusting for the page size
options.PageSetup.AdjustToWidestPage = true;

// Prepare a path to save the converted file 
string savePath = Path.Combine(OutputDir, "output-widest-page-size.pdf");

// Create the PdfDevice and specify options and output file
using PdfDevice device = new PdfDevice(options, savePath);

// Render HTML to PDF
document.RenderTo(device);

Pour en savoir plus sur le processus de rendu, veuillez lire l’article Dispositif de rendu – Rendering Device.

Si vous souhaitez savoir comment utiliser les options de rendu pour redimensionner les pages d’un document en fonction de la taille du contenu et vice versa, veuillez consulter l’article Comment redimensionner un document lors d’une conversion à partir de HTML ?

Options de rendu PDF

La classe PdfRenderingOptions, en plus des options générales, supporte certains paramètres spécifiques, tels que JpegQuality, DocumentInfo, Encryption, et FormFieldBehaviour.

Property	Description
JpegQuality	Specifies the quality of JPEG compression for images. The default value is 95.
DocumentInfo	This property contains information about the output PDF document.
Encryption	This property gets or sets encryption details. If it is not set, then no encryption will be performed.
FormFieldBehaviour	This property specifies the behavior of form fields in the output PDF document.

La propriété FormFieldBehaviour est utilisée pour spécifier le comportement des champs de formulaire dans un document PDF. Pour savoir ce que signifie aplatir un fichier PDF et comment le faire à l’aide de la bibliothèque Aspose.HTML for .NET, veuillez consulter l’article Aplatir un PDF – Flatten PDF.

Le code C# suivant montre comment ajouter du cryptage à un fichier de sortie PDF en utilisant la classe PdfRenderingOptions :

// Render HTML to PDF with password protection using C#

// Prepare a path to a source HTML file
string documentPath = Path.Combine(DataDir, "document.html");

// Initialize the HTML document from the file
using HTMLDocument document = new HTMLDocument(documentPath);

// Create the instance of Rendering Options
PdfRenderingOptions options = new PdfRenderingOptions();

// Set the permissions to the file
options.Encryption = new PdfEncryptionInfo(
        "user_pwd",
        "owner_pwd",
        PdfPermissions.PrintDocument,
        PdfEncryptionAlgorithm.RC4_128);

// Prepare a path to save the converted file 
string savePath = Path.Combine(OutputDir, "output-options.pdf");

// Create an instance of the PdfDevice and specify options and output file
using PdfDevice device = new PdfDevice(options, savePath);

// Render HTML to PDF
document.RenderTo(device);

L’exemple ci-dessus montre comment créer une nouvelle instance de PdfRenderingOptions et définir les options de cryptage pour un fichier de sortie PDF. Pour cela, vous devez utiliser le constructeur PdfEncryptionInfo(userPassword, ownerPassword, permissions, encryptionAlgorithm) pour créer un objet PdfEncryptionInfo, qui définit les paramètres de cryptage pour le fichier PDF. Le constructeur prend quatre paramètres :

• userPassword et ownerPassword, qui sont nécessaires pour ouvrir et travailler avec le fichier PDF ;
• permissions – un ensemble de permissions autorisées pour un fichier PDF. Dans ce cas, PdfPermissions.PrintDocument est spécifié, ce qui permet à l’utilisateur d’imprimer le document ;
• encryptionAlgorithm – l’algorithme de cryptage utilisé pour sécuriser le fichier PDF. Dans ce cas, PdfEncryptionAlgorithm.RC4_128 est utilisé, qui est un algorithme de cryptage RC4 de 128 bits.

Options de rendu d’image

La classe ImageRenderingOptions prend en charge toutes les options générales et vous permet de configurer des options spécifiques, telles que l’anticrénelage, la configuration du rendu du texte, la sélection du format de l’image et la compression de l’image.

Property	Description
Compression	Sets Tagged Image File Format (TIFF) Compression. By default, this property is LZW.
Format	Sets the ImageFormat (JPG, PNG, BMP, TIFF, or GIF). By default, this property is PNG.
UseAntialiasing	This property sets the rendering quality for the image.
Text	Gets a TextOptions object which is used for configuration of text rendering.

Voyons comment utiliser un objet spécialisé ImageRenderingOptions pour configurer la qualité de rendu de l’image. L’exemple suivant montre comment modifier la résolution et l’anticrénelage de l’image résultante.

// Render HTML to JPG with custom resolution and antialiasing settings with C#

// Prepare a path to a source HTML file
string documentPath = Path.Combine(DataDir, "color.html");

// Initialize the HTML document from the file
using HTMLDocument document = new HTMLDocument(documentPath);

// Create an instance of Rendering Options
ImageRenderingOptions options = new ImageRenderingOptions(ImageFormat.Jpeg)
{
    // Disable smoothing mode
    UseAntialiasing = false,

    // Set the image resolution as 75 dpi
    VerticalResolution = Resolution.FromDotsPerInch(75),
    HorizontalResolution = Resolution.FromDotsPerInch(75),
};

// Prepare a path to save the converted file 
string savePath = Path.Combine(OutputDir, "color-options.jpg");

// Create an instance of the ImageDevice and specify options and output file
using ImageDevice device = new ImageDevice(options, savePath);

// Render HTML to JPG
document.RenderTo(device);

Options de rendu XPS

Les fichiers XPS générés par notre bibliothèque n’ont pas de paramètres spécifiques. Tous les paramètres de XpsRenderingOptions sont hérités de la classe de base RenderingOptions et décrits [ici].(51)

// Render HTML to XPS with custom page size using C#

// Prepare a path to a source HTML file
string documentPath = Path.Combine(DataDir, "document.html");

// Initialize the HTML document from the file
using HTMLDocument document = new HTMLDocument(documentPath);

// Create an instance of Rendering Options
XpsRenderingOptions options = new XpsRenderingOptions();
options.PageSetup.AnyPage = new Page(new Size(Length.FromInches(5), Length.FromInches(2)));

// Prepare a path to save the converted file 
string savePath = Path.Combine(OutputDir, "document-options.xps");

// Create an instance of the XpsDevice and specify options and output file
using XpsDevice device = new XpsDevice(options, savePath);

// Render HTML to XPS
document.RenderTo(device);

Options de rendu du DOC

La classe DocRenderingOptions prend en charge toutes les options générales et vous permet de personnaliser les propriétés FontEmbeddingRule et DocumentFormat pour le fichier de sortie.

Property	Description
FontEmbeddingRule	This property gets or sets the font embedding rule. Available values are Full and None. The default value is None.
DocumentFormat	This property gets or sets the file format of the output document. The default value is DOCX.

L’exemple suivant montre comment personnaliser les options de rendu des documents de sortie en définissant la taille de la page et la règle d’intégration des polices :

// Render HTML to DOCX in C# with custom page settings

// Prepare a path to a source HTML file
string documentPath = Path.Combine(DataDir, "nature.html");

// Initialize the HTML document from the file
using HTMLDocument document = new HTMLDocument(documentPath);

// Create an instance of Rendering Options and set a custom page size
DocRenderingOptions options = new DocRenderingOptions();
options.PageSetup.AnyPage = new Page(new Size(Length.FromInches(8), Length.FromInches(10)));
options.FontEmbeddingRule = (FontEmbeddingRule.Full);

// Prepare a path to save the converted file 
string savePath = Path.Combine(OutputDir, "nature-options.docx");

// Create an instance of the DocDevice and specify options and output file
using DocDevice device = new DocDevice(options, savePath);

// Render HTML to DOCX
document.RenderTo(device);

Aspose.HTML propose des Convertisseurs gratuits en ligne qui permettent de convertir des fichiers HTML, XHTML, MHTML, EPUB, XML et Markdown dans toute une série de formats populaires. Vous pouvez facilement convertir vos documents HTML en PDF, XPS, DOCX, JPG, PNG, GIF, TIFF et autres. Il vous suffit de sélectionner un fichier, de choisir le format à convertir et le tour est joué. Cerise sur le gâteau, c’est entièrement gratuit !