Gérer les paragraphes de texte PowerPoint en Python

À propos de cette page

Apprenez à créer et formater des paragraphes, des portions, des puces, des listes numérotées, des retraits, du contenu HTML et des images de paragraphes avec Aspose.Slides pour Python via .NET.

Vue d’ensemble

Aspose.Slides for Python via .NET représente le texte comme une hiérarchie de zones de texte, de paragraphes et de portions :

TextFrame représente le conteneur de texte dans une forme et fournit l’accès à sa collection de paragraphes.
Paragraph représente un paragraphe dans une zone de texte et fournit l’accès à ses portions ainsi qu’au formatage au niveau du paragraphe.
Portion représente une séquence de texte dans un paragraphe. Chaque portion peut avoir son propre texte et un formatage au niveau des caractères.

Un paragraphe peut donc contenir du texte avec différentes polices, couleurs, tailles et autres formatages en utilisant plusieurs portions.

Créer et formater des paragraphes

Créer des paragraphes avec plusieurs portions

Les étapes suivantes créent une zone de texte avec trois paragraphes, chacun contenant trois portions :

Créer une instance de la classe Presentation.
Accéder à la diapositive concernée via son indice.
Ajouter une AutoShape rectangulaire à la diapositive.
Accéder au TextFrame de la forme.
Utiliser le paragraphe par défaut et ajouter deux autres objets Paragraph à la zone de texte.
Ajouter suffisamment d’objets Portion pour que chaque paragraphe contienne trois portions. Le paragraphe par défaut contient déjà une portion vide.
Définir le texte de chaque portion.
Appliquer le formatage au niveau des caractères via Portion.portion_format.
Enregistrer la présentation modifiée.

Cet exemple Python implémente les étapes :

import aspose.pydrawing as draw
import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 50, 150, 300, 150)
    text_frame = shape.text_frame

    first_paragraph = text_frame.paragraphs[0]
    first_paragraph.portions.add(slides.Portion())
    first_paragraph.portions.add(slides.Portion())

    second_paragraph = slides.Paragraph()
    second_paragraph.portions.add(slides.Portion())
    second_paragraph.portions.add(slides.Portion())
    second_paragraph.portions.add(slides.Portion())
    text_frame.paragraphs.add(second_paragraph)

    third_paragraph = slides.Paragraph()
    third_paragraph.portions.add(slides.Portion())
    third_paragraph.portions.add(slides.Portion())
    third_paragraph.portions.add(slides.Portion())
    text_frame.paragraphs.add(third_paragraph)

    for paragraph_index in range(text_frame.paragraphs.count):
        paragraph = text_frame.paragraphs[paragraph_index]
        for portion_index in range(paragraph.portions.count):
            portion = paragraph.portions[portion_index]
            portion.text = f"Portion {paragraph_index + 1}.{portion_index + 1}"

            if portion_index == 0:
                portion.portion_format.fill_format.fill_type = slides.FillType.SOLID
                portion.portion_format.fill_format.solid_fill_color.color = draw.Color.red
                portion.portion_format.font_bold = slides.NullableBool.TRUE
                portion.portion_format.font_height = 15
            elif portion_index == 1:
                portion.portion_format.fill_format.fill_type = slides.FillType.SOLID
                portion.portion_format.fill_format.solid_fill_color.color = draw.Color.blue
                portion.portion_format.font_italic = slides.NullableBool.TRUE
                portion.portion_format.font_height = 18

    presentation.save("paragraphs_with_portions.pptx", slides.export.SaveFormat.PPTX)

Créer des listes à puces et numérotées

Créer une liste à puces ou numérotée

Les puces et la numérotation facilitent la lecture des éléments connexes. Dans Aspose.Slides, les paramètres de liste sont définis via BulletFormat.

Créer une instance de la classe Presentation.
Accéder à la diapositive concernée via son indice.
Ajouter une AutoShape à la diapositive sélectionnée.
Accéder au TextFrame de la forme.
Supprimer le paragraphe par défaut de la zone de texte.
Créer un Paragraph pour une puce symbole.
Définir BulletFormat.type sur BulletType.SYMBOL et spécifier le caractère de la puce.
Définir le texte du paragraphe, le retrait, la couleur de la puce et la hauteur de la puce.
Ajouter le paragraphe à la zone de texte.
Créer un deuxième paragraphe et définir BulletFormat.type sur BulletType.NUMBERED.
Configurer le style de la puce numérotée et ajouter le paragraphe à la zone de texte.
Enregistrer la présentation.

Cet exemple Python crée une puce symbole et une puce numérotée :

import aspose.pydrawing as draw
import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 200, 200, 400, 200)
    text_frame = shape.text_frame
    text_frame.paragraphs.clear()

    symbol_paragraph = slides.Paragraph()
    symbol_paragraph.text = "Welcome to Aspose.Slides"
    symbol_paragraph.paragraph_format.bullet.type = slides.BulletType.SYMBOL
    symbol_paragraph.paragraph_format.bullet.char = chr(0x2022)
    symbol_paragraph.paragraph_format.indent = 25
    symbol_paragraph.paragraph_format.bullet.color.color_type = slides.ColorType.RGB
    symbol_paragraph.paragraph_format.bullet.color.color = draw.Color.black
    symbol_paragraph.paragraph_format.bullet.is_bullet_hard_color = slides.NullableBool.TRUE
    symbol_paragraph.paragraph_format.bullet.height = 100
    text_frame.paragraphs.add(symbol_paragraph)

    numbered_paragraph = slides.Paragraph()
    numbered_paragraph.text = "This is a numbered item"
    numbered_paragraph.paragraph_format.bullet.type = slides.BulletType.NUMBERED
    numbered_paragraph.paragraph_format.bullet.numbered_bullet_style = slides.NumberedBulletStyle.BULLET_CIRCLE_NUM_WD_BLACK_PLAIN
    numbered_paragraph.paragraph_format.indent = 25
    numbered_paragraph.paragraph_format.bullet.color.color_type = slides.ColorType.RGB
    numbered_paragraph.paragraph_format.bullet.color.color = draw.Color.black
    numbered_paragraph.paragraph_format.bullet.is_bullet_hard_color = slides.NullableBool.TRUE
    numbered_paragraph.paragraph_format.bullet.height = 100
    text_frame.paragraphs.add(numbered_paragraph)

    presentation.save("bulleted_and_numbered_list.pptx", slides.export.SaveFormat.PPTX)

Utiliser des puces d’image

Les puces d’image vous permettent d’utiliser une image personnalisée à la place d’un symbole ou d’un chiffre.

Créer une instance de la classe Presentation.
Accéder à la diapositive concernée via son indice.
Ajouter une AutoShape et accéder à son TextFrame.
Supprimer le paragraphe par défaut de la zone de texte.
Charger l’image de la puce et l’ajouter à la collection d’images de la présentation sous forme de PPImage.
Créer un Paragraph et définir son texte.
Définir BulletFormat.type sur BulletType.PICTURE.
Attribuer l’image via BulletFormat.picture et définir la hauteur de la puce.
Ajouter le paragraphe à la zone de texte.
Enregistrer la présentation modifiée.

Cet exemple Python crée une puce d’image :

import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    with slides.Images.from_file("bullets.png") as bullet_image:
        presentation_image = presentation.images.add_image(bullet_image)

    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 200, 200, 400, 200)
    text_frame = shape.text_frame
    text_frame.paragraphs.clear()

    paragraph = slides.Paragraph()
    paragraph.text = "Welcome to Aspose.Slides"
    paragraph.paragraph_format.bullet.type = slides.BulletType.PICTURE
    paragraph.paragraph_format.bullet.picture.image = presentation_image
    paragraph.paragraph_format.bullet.height = 100
    text_frame.paragraphs.add(paragraph)

    presentation.save("picture_bullet.pptx", slides.export.SaveFormat.PPTX)
    presentation.save("picture_bullet.ppt", slides.export.SaveFormat.PPT)

Créer une liste à plusieurs niveaux

Définir ParagraphFormat.depth pour placer les paragraphes à différents niveaux d’une liste. Le niveau supérieur a une profondeur de 0.

Créer une Presentation et accéder à une diapositive.
Ajouter une AutoShape et supprimer le paragraphe par défaut de sa zone de texte.
Créer quatre paragraphes et configurer leurs symboles de puces.
Définir leurs valeurs ParagraphFormat.depth à 0, 1, 2 et 3.
Ajouter les paragraphes à la zone de texte et enregistrer la présentation.

Cet exemple Python crée une liste à puces à quatre niveaux :

import aspose.pydrawing as draw
import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 200, 200, 400, 200)
    text_frame = shape.text_frame
    text_frame.paragraphs.clear()

    first_paragraph = slides.Paragraph()
    first_paragraph.text = "Content"
    first_paragraph.paragraph_format.bullet.type = slides.BulletType.SYMBOL
    first_paragraph.paragraph_format.bullet.char = chr(0x2022)
    first_paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    first_paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    first_paragraph.paragraph_format.depth = 0

    second_paragraph = slides.Paragraph()
    second_paragraph.text = "Second level"
    second_paragraph.paragraph_format.bullet.type = slides.BulletType.SYMBOL
    second_paragraph.paragraph_format.bullet.char = "-"
    second_paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    second_paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    second_paragraph.paragraph_format.depth = 1

    third_paragraph = slides.Paragraph()
    third_paragraph.text = "Third level"
    third_paragraph.paragraph_format.bullet.type = slides.BulletType.SYMBOL
    third_paragraph.paragraph_format.bullet.char = chr(0x2022)
    third_paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    third_paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    third_paragraph.paragraph_format.depth = 2

    fourth_paragraph = slides.Paragraph()
    fourth_paragraph.text = "Fourth level"
    fourth_paragraph.paragraph_format.bullet.type = slides.BulletType.SYMBOL
    fourth_paragraph.paragraph_format.bullet.char = "-"
    fourth_paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    fourth_paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    fourth_paragraph.paragraph_format.depth = 3

    text_frame.paragraphs.add(first_paragraph)
    text_frame.paragraphs.add(second_paragraph)
    text_frame.paragraphs.add(third_paragraph)
    text_frame.paragraphs.add(fourth_paragraph)

    presentation.save("multilevel_list.pptx", slides.export.SaveFormat.PPTX)

Commencer les éléments de liste numérotée à des valeurs personnalisées

Utilisez BulletFormat.numbered_bullet_start_with pour définir le numéro initial affiché pour un paragraphe numéroté.

Créer une Presentation et ajouter une AutoShape à une diapositive.
Supprimer le paragraphe par défaut de la zone de texte de la forme.
Créer trois paragraphes numérotés.
Définir BulletFormat.numbered_bullet_start_with sur 2, 3 et 7 pour les paragraphes respectifs.
Ajouter les paragraphes à la zone de texte et enregistrer la présentation.

Cet exemple Python attribue un numéro de départ personnalisé à chaque paragraphe :

import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 200, 200, 400, 200)
    text_frame = shape.text_frame
    text_frame.paragraphs.clear()

    first_paragraph = slides.Paragraph()
    first_paragraph.text = "Start at 2"
    first_paragraph.paragraph_format.bullet.type = slides.BulletType.NUMBERED
    first_paragraph.paragraph_format.bullet.numbered_bullet_start_with = 2
    text_frame.paragraphs.add(first_paragraph)

    second_paragraph = slides.Paragraph()
    second_paragraph.text = "Start at 3"
    second_paragraph.paragraph_format.bullet.type = slides.BulletType.NUMBERED
    second_paragraph.paragraph_format.bullet.numbered_bullet_start_with = 3
    text_frame.paragraphs.add(second_paragraph)

    third_paragraph = slides.Paragraph()
    third_paragraph.text = "Start at 7"
    third_paragraph.paragraph_format.bullet.type = slides.BulletType.NUMBERED
    third_paragraph.paragraph_format.bullet.numbered_bullet_start_with = 7
    text_frame.paragraphs.add(third_paragraph)

    presentation.save("custom_numbered_list.pptx", slides.export.SaveFormat.PPTX)

Contrôler la mise en page du paragraphe et les propriétés de fin

Définir un retrait de première ligne

Utilisez la propriété ParagraphFormat.indent pour contrôler le retrait de la première ligne d’un paragraphe. Cette propriété déplace uniquement la première ligne par rapport à la marge gauche du paragraphe. Une valeur positive décale la première ligne vers la droite, tandis que les lignes restantes restent alignées au corps du paragraphe.

Utilisez ParagraphFormat.margin_left lorsque vous devez déplacer tout le paragraphe. Utilisez ParagraphFormat.indent lorsque vous ne devez déplacer que la première ligne.

L’exemple ci‑dessous crée plusieurs paragraphes et applique différentes valeurs ParagraphFormat.indent pour montrer comment le retrait de première ligne affecte la mise en page du paragraphe.

Créer une instance de la classe Presentation.
Accéder à la diapositive cible.
Ajouter une AutoShape rectangulaire à la diapositive.
Accéder au TextFrame de la forme et supprimer le paragraphe par défaut.
Créer plusieurs paragraphes et définir différentes valeurs ParagraphFormat.indent pour ceux‑ci.
Ajouter les paragraphes à la zone de texte.
Enregistrer la présentation modifiée.

Ce code montre comment définir un retrait de paragraphe :

import aspose.pydrawing as draw
import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 50, 50, 420, 220)
    shape.fill_format.fill_type = slides.FillType.NO_FILL
    shape.line_format.fill_format.fill_type = slides.FillType.SOLID
    shape.line_format.fill_format.solid_fill_color.color = draw.Color.gray

    text_frame = shape.text_frame
    text_frame.text_frame_format.autofit_type = slides.TextAutofitType.SHAPE
    text_frame.paragraphs.clear()

    first_paragraph = slides.Paragraph()
    first_paragraph.text = "No first-line indent. Wrapped lines start at the same position as the first line."
    first_paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    first_paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    first_paragraph.paragraph_format.margin_left = 20
    first_paragraph.paragraph_format.indent = 0

    second_paragraph = slides.Paragraph()
    second_paragraph.text = "First-line indent of 20 points. The first line moves to the right, while wrapped lines remain aligned to the paragraph body."
    second_paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    second_paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    second_paragraph.paragraph_format.margin_left = 20
    second_paragraph.paragraph_format.indent = 20

    third_paragraph = slides.Paragraph()
    third_paragraph.text = "First-line indent of 40 points. This paragraph shows a larger first-line offset to make the effect easier to see."
    third_paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    third_paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    third_paragraph.paragraph_format.margin_left = 20
    third_paragraph.paragraph_format.indent = 40

    text_frame.paragraphs.add(first_paragraph)
    text_frame.paragraphs.add(second_paragraph)
    text_frame.paragraphs.add(third_paragraph)

    presentation.save("paragraph_indent.pptx", slides.export.SaveFormat.PPTX)

Le résultat :

Le retrait de première ligne des paragraphes

Définir un retrait suspendu

Un retrait suspendu est une mise en page de paragraphe dans laquelle la première ligne commence à gauche des lignes restantes. Dans Aspose.Slides, vous créez cet effet avec la propriété ParagraphFormat.indent. Définissez indent à une valeur négative pour déplacer la première ligne vers la gauche par rapport au corps du paragraphe.

En pratique, ParagraphFormat.margin_left définit la position gauche du corps du paragraphe, et ParagraphFormat.indent définit la position de la première ligne par rapport à cette marge. Pour créer un retrait suspendu, définissez une valeur positive margin_left et une valeur négative indent.

Ce formatage est utile pour les bibliographies, références, entrées de glossaire, et autres paragraphes où les lignes renvoyées doivent s’aligner sous le corps du paragraphe plutôt que sous le premier caractère de la première ligne.

Créer une instance de la classe Presentation.
Accéder à la diapositive cible.
Ajouter une AutoShape rectangulaire à la diapositive.
Accéder au TextFrame de la forme et supprimer le paragraphe par défaut.
Créer des paragraphes et définir une valeur positive ParagraphFormat.margin_left pour chaque paragraphe.
Définir une valeur négative ParagraphFormat.indent pour créer l’effet de retrait suspendu.
Ajouter les paragraphes à la zone de texte.
Enregistrer la présentation modifiée.

Ce code montre comment définir un retrait suspendu pour un paragraphe :

import aspose.pydrawing as draw
import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 50, 50, 420, 220)
    shape.fill_format.fill_type = slides.FillType.NO_FILL
    shape.line_format.fill_format.fill_type = slides.FillType.SOLID
    shape.line_format.fill_format.solid_fill_color.color = draw.Color.gray

    text_frame = shape.text_frame
    text_frame.text_frame_format.autofit_type = slides.TextAutofitType.SHAPE
    text_frame.paragraphs.clear()

    first_paragraph = slides.Paragraph()
    first_paragraph.text = "A hanging indent is created by combining a positive left margin with a negative indent. The first line starts to the left, while wrapped lines align with the paragraph body."
    first_paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    first_paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    first_paragraph.paragraph_format.margin_left = 40
    first_paragraph.paragraph_format.indent = -20

    second_paragraph = slides.Paragraph()
    second_paragraph.text = "This second example uses a deeper hanging indent so the difference between the first line and the wrapped lines is easier to compare."
    second_paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    second_paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    second_paragraph.paragraph_format.margin_left = 60
    second_paragraph.paragraph_format.indent = -30

    text_frame.paragraphs.add(first_paragraph)
    text_frame.paragraphs.add(second_paragraph)

    presentation.save("hanging_indent.pptx", slides.export.SaveFormat.PPTX)

Le résultat :

Le retrait suspendu des paragraphes

Définir les propriétés de fin d’exécution du paragraphe

La propriété Paragraph.end_paragraph_portion_format contrôle le formatage du caractère de fin de paragraphe. L’exemple suivant attribue une taille de police et une police latine au caractère de fin du deuxième paragraphe :

Charger une Presentation et accéder à une diapositive.
Ajouter une AutoShape et supprimer son paragraphe par défaut.
Créer deux paragraphes et ajouter des portions de texte à ceux‑ci.
Créer un PortionFormat pour le caractère de fin du deuxième paragraphe.
Définir PortionFormat.font_height et PortionFormat.latin_font.
Attribuer le format à Paragraph.end_paragraph_portion_format et enregistrer la présentation.

import aspose.slides as slides

with slides.Presentation("Test.pptx") as presentation:
    slide = presentation.slides[0]
    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 10, 10, 200, 250)
    text_frame = shape.text_frame
    text_frame.paragraphs.clear()

    first_paragraph = slides.Paragraph()
    first_paragraph.portions.add(slides.Portion("Sample text"))

    second_paragraph = slides.Paragraph()
    second_paragraph.portions.add(slides.Portion("Sample text 2"))

    end_paragraph_format = slides.PortionFormat()
    end_paragraph_format.font_height = 48
    end_paragraph_format.latin_font = slides.FontData("Times New Roman")
    second_paragraph.end_paragraph_portion_format = end_paragraph_format

    text_frame.paragraphs.add(first_paragraph)
    text_frame.paragraphs.add(second_paragraph)

    presentation.save("end_paragraph_format.pptx", slides.export.SaveFormat.PPTX)

Compter les lignes rendues

Pour les règles de paragraphe qui affectent le renvoi à la ligne automatique et la ponctuation en fin de ligne, voir Contrôle du saut de ligne et Contrôle de la ponctuation suspendue.

Utilisez Paragraph.get_lines_count pour compter les lignes occupées par un paragraphe après la mise en page du texte, y compris le renvoi à la ligne automatique. Cela est utile lors de la vérification de la longueur du texte et de la mise en page dans les modèles de présentation.

Un paragraphe est un élément de TextFrame.paragraphs et peut occuper plusieurs lignes rendues. Un saut de ligne explicite à l’intérieur d’un paragraphe force une nouvelle ligne sans créer un autre paragraphe. Le renvoi à la ligne automatique crée des lignes en fonction de la largeur disponible sans insérer de sauts de ligne explicites dans le texte. Comptabiliser les paragraphes ou les caractères de saut de ligne ne donne donc pas le nombre de lignes rendues.

L’exemple suivant crée une forme de texte, compte ses lignes, rétrécit la forme, puis remplace le texte par une chaîne plus courte. Le renvoi à la ligne est activé et l’ajustement automatique est désactivé afin que la largeur de la forme contrôle le renvoi sans réduire automatiquement le texte ou redimensionner la forme. Les dimensions de la forme sont en points. Enfin, l’exemple ajoute un autre paragraphe et additionne les comptes de lignes dans la zone de texte.

import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 50, 50, 400, 200)
    text_frame = shape.text_frame
    text_frame.text_frame_format.wrap_text = slides.NullableBool.TRUE
    text_frame.text_frame_format.autofit_type = slides.TextAutofitType.NONE

    paragraph = text_frame.paragraphs[0]
    paragraph.paragraph_format.default_portion_format.font_height = 20
    paragraph.text = "This text demonstrates how automatic wrapping changes the number of rendered lines."
    print(f"Original width: {paragraph.get_lines_count()}")

    shape.width = 150
    print(f"Narrower shape: {paragraph.get_lines_count()}")

    paragraph.text = "Short text."
    print(f"Shorter text: {paragraph.get_lines_count()}")

    second_paragraph = slides.Paragraph()
    second_paragraph.text = "Another paragraph."
    second_paragraph.paragraph_format.default_portion_format.font_height = 20
    text_frame.paragraphs.add(second_paragraph)

    total_line_count = 0
    for current_paragraph in text_frame.paragraphs:
        total_line_count += current_paragraph.get_lines_count()
    print(f"Total lines in the text frame: {total_line_count}")

Avec ce texte et ces dimensions, rétrécir la forme augmente le nombre de lignes, tandis que remplacer le texte par la courte chaîne le réduit. Les comptes exacts peuvent varier selon la disponibilité et la substitution des polices, la taille des caractères, les marges, le retrait, le renvoi à la ligne et les paramètres d’ajustement automatique. Utilisez les polices et les paramètres de mise en page prévus pour l’environnement cible lors de la validation d’un modèle.

Le compte de lignes seul ne détermine pas si le texte déborde de son conteneur. La hauteur disponible, la hauteur des lignes, l’espacement des paragraphes et des lignes, ainsi que le comportement d’ajustement automatique sont également importants ; même une seule ligne peut dépasser la largeur disponible lorsque le renvoi à la ligne est désactivé.

Importer et exporter le contenu du paragraphe

Importer du texte HTML dans des paragraphes

Utilisez ParagraphCollection.add_from_html pour convertir le balisage HTML en paragraphes et portions dans une zone de texte.

Créer une instance de la classe Presentation.
Accéder à une diapositive et ajouter une AutoShape.
Accéder au TextFrame de la forme et supprimer son paragraphe par défaut.
Lire le fichier HTML source.
Passer la chaîne HTML à ParagraphCollection.add_from_html.
Enregistrer la présentation modifiée.

Cet exemple Python importe du HTML dans une zone de texte :

import aspose.slides as slides

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    shape_width = presentation.slide_size.size.width - 20
    shape_height = presentation.slide_size.size.height - 20
    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 10, 10, shape_width, shape_height)
    shape.fill_format.fill_type = slides.FillType.NO_FILL
    shape.text_frame.paragraphs.clear()

    with open("file.html", "r", encoding="utf-8") as html_stream:
        html = html_stream.read()

    shape.text_frame.paragraphs.add_from_html(html)
    presentation.save("html_text.pptx", slides.export.SaveFormat.PPTX)

Exporter le texte d’un paragraphe vers HTML

Utilisez ParagraphCollection.export_to_html pour exporter une plage sélectionnée de paragraphes en HTML.

Créer une instance de la classe Presentation et charger la présentation souhaitée.
Accéder à la diapositive et trouver la AutoShape qui contient le texte.
Accéder au TextFrame de la forme.
Appeler ParagraphCollection.export_to_html avec l’indice du paragraphe de départ et le nombre de paragraphes à exporter.
Écrire la chaîne HTML renvoyée dans un fichier.

Cet exemple Python exporte tous les paragraphes de la première forme de texte :

import aspose.slides as slides

with slides.Presentation("ExportingHTMLText.pptx") as presentation:
    shape = presentation.slides[0].shapes[0]

    if isinstance(shape, slides.AutoShape) and shape.text_frame is not None:
        paragraphs = shape.text_frame.paragraphs
        html = paragraphs.export_to_html(0, paragraphs.count, None)
        with open("paragraphs.html", "w", encoding="utf-8") as html_stream:
            html_stream.write(html)
    else:
        print("The first shape is not a text shape.")

Rendre un paragraphe sous forme d’image

Paragraph fournit la méthode get_image pour rendre directement un paragraphe individuel. La méthode renvoie un IImage que vous pouvez enregistrer dans un fichier ou un flux avec IImage.save. Vous n’avez pas besoin de rendre la forme contenant ou de recadrer manuellement un bitmap.

La méthode get_image peut renvoyer None si le paragraphe est introuvable dans sa collection parent, n’a pas de limites de rendu valides, ou ne peut pas être rendu. Vérifiez le résultat avant de l’enregistrer et utilisez l’image renvoyée comme gestionnaire de contexte pour libérer ses ressources.

Rendre un paragraphe à l’échelle par défaut

Supposons que nous ayons un fichier de présentation appelé sample.pptx contenant une diapositive, où la première forme est une zone de texte contenant trois paragraphes.

La zone de texte avec trois paragraphes

L’exemple suivant rend le deuxième paragraphe d’une forme de texte ordinaire à l’échelle par défaut et enregistre l’image renvoyée au format PNG :

import aspose.slides as slides

with slides.Presentation("sample.pptx") as presentation:
    shape = presentation.slides[0].shapes[0]

    if isinstance(shape, slides.AutoShape) and shape.text_frame is not None and shape.text_frame.paragraphs.count > 1:
        paragraph = shape.text_frame.paragraphs[1]
        paragraph_image = paragraph.get_image()

        if paragraph_image is not None:
            with paragraph_image:
                paragraph_image.save("paragraph.png", slides.ImageFormat.PNG)
        else:
            print("The paragraph could not be rendered.")
    else:
        print("The expected text shape or paragraph was not found.")

Le résultat :

L’image du paragraphe

Rendre un paragraphe dans une cellule de tableau avec mise à l’échelle

Passez des facteurs d’échelle horizontaux et verticaux à get_image pour contrôler la taille du paragraphe rendu. L’exemple suivant crée un tableau, rend le paragraphe dans sa première cellule à deux fois sa largeur et hauteur par défaut, et enregistre le résultat sous forme d’image PNG :

import aspose.slides as slides

scale_x = 2
scale_y = 2

with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    table = slide.shapes.add_table(50, 50, [300], [80])
    paragraph = table.rows[0][0].text_frame.paragraphs[0]
    paragraph.text = "Text in a table cell"

    paragraph_image = paragraph.get_image(scale_x, scale_y)
    if paragraph_image is not None:
        with paragraph_image:
            paragraph_image.save("table_paragraph.png", slides.ImageFormat.PNG)
    else:
        print("The paragraph could not be rendered.")

Un facteur d’échelle de 1 maintient cet axe à sa taille de pixel par défaut. Par exemple, 2 pour les deux facteurs produit une image dont la largeur et la hauteur sont approximativement deux fois les dimensions par défaut, ce qui donne quatre fois plus de pixels. Des facteurs plus élevés produisent généralement un texte plus net pour le zoom ou les sorties haute résolution, mais augmentent également la consommation de mémoire et la taille du fichier. Des facteurs inférieurs à 1 produisent des images plus petites avec moins de détails. Utilisez des facteurs égaux pour préserver le rapport d’aspect du paragraphe ; des facteurs horizontaux et verticaux différents étirent la sortie indépendamment.

Rendre une forme entière avec Shape.get_image reste utile lorsque la sortie doit inclure le remplissage, la bordure ou autre contexte visuel de la forme. Pour une image contenant uniquement le paragraphe, utilisez Paragraph.get_image.

FAQ

Puis-je désactiver complètement le renvoi à la ligne à l’intérieur d’une zone de texte?

Oui. Définissez TextFrameFormat.wrap_text pour désactiver le renvoi afin que les lignes ne se cassent pas aux bords de la zone de texte.

Comment obtenir les limites exactes sur la diapositive d’un paragraphe spécifique?

Utilisez Paragraph.get_rect pour récupérer le rectangle englobant du paragraphe. Portion.get_rect fournit les limites d’une portion individuelle.

Où le alignement du paragraphe (gauche, droite, centre ou justifié) est‑il contrôlé?

ParagraphFormat.alignment est un paramètre au niveau du paragraphe et s’applique à tout le paragraphe quel que soit le formatage des portions individuelles.

Pour aligner verticalement les portions de tailles de police différentes dans chaque ligne, voir Aligner les polices dans une ligne.

Puis‑je définir la langue de vérification pour une partie d’un paragraphe?

Oui. Définissez PortionFormat.language_id pour les portions individuelles, ainsi un paragraphe peut contenir du texte dans plusieurs langues.

Améliorez vos présentations avec AutoFit en Python Obtenir les limites des paragraphes à partir de présentations en Python