Formater le texte de la présentation en Python

Vue d’ensemble

Cet article montre comment formater du texte dans les présentations PowerPoint et OpenDocument à l’aide d’Aspose.Slides pour Python via .NET. Il couvre les couleurs d’arrière-plan, la transparence, l’espacement des caractères, les propriétés de police, la rotation, l’espacement des paragraphes, le comportement d’ajustement automatique, l’ancrage du texte, les tabulations et les paramètres de langue.

Sauf indication contraire, les exemples utilisent sample.pptx. La première forme de la première diapositive est une zone de texte, et son premier paragraphe contient le texte affiché ci-dessous. Les indices de diapositive et de forme sont basés sur zéro. Les exemples qui sélectionnent des portions en gras utilisent le formatage effectif, y compris le formatage gras hérité :

Texte d’exemple

Pour trouver et mettre en surbrillance du texte littéral ou des correspondances d’expressions régulières, voir Recherche et remplacement de texte.

Définir la couleur d’arrière-plan du texte

Utilisez ParagraphFormat.default_portion_format pour définir la couleur de surbrillance par défaut d’un paragraphe, ou utilisez BasePortionFormat.highlight_color pour des portions de texte individuelles.

L’exemple suivant définit une surbrillance gris clair comme valeur par défaut pour le premier paragraphe. Les couleurs de surbrillance explicites sur les portions individuelles ont la priorité sur cette valeur par défaut :

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

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    # Définir la couleur de surbrillance pour le paragraphe entier.
    paragraph.paragraph_format.default_portion_format.highlight_color.color = draw.Color.light_gray

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

Le résultat :

Le paragraphe gris

L’exemple de code ci-dessous montre comment définir la couleur d’arrière-plan pour les portions de texte avec une police en gras :

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

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    for portion in paragraph.portions:
        if portion.portion_format.get_effective().font_bold:
            # Définir la couleur de surbrillance pour la portion de texte.
            portion.portion_format.highlight_color.color = draw.Color.light_gray

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

Le résultat :

Les portions de texte gris

Aligner les paragraphes de texte

Utilisez ParagraphFormat.alignment pour définir l’alignement des paragraphes à l’intérieur d’un cadre de texte. La valeur peut être centrée, alignée à gauche, alignée à droite, justifiée, etc.

L’exemple de code suivant montre comment aligner le paragraphe au centre :

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    # Définir l'alignement du paragraphe au centre.
    paragraph.paragraph_format.alignment = slides.TextAlignment.CENTER

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

Le résultat :

Le paragraphe aligné

Aligner les polices à l’intérieur d’une ligne

Utilisez ParagraphFormat.font_alignment pour aligner verticalement les portions de texte de différentes tailles de police au sein d’une ligne. Ce réglage s’applique à tout le paragraphe et contrôle l’alignement au sein de chacune de ses lignes.

L’exemple autonome suivant crée quatre zones de texte étiquetées sur une diapositive. Chaque paragraphe contient le même texte en 18, 36 et 54 points, avec un alignement de police différent. Il utilise Arial, désactive l’ajustement automatique et le retour à la ligne, et maintient les cadres de texte suffisamment grands pour une seule ligne.

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

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

    alignments = [slides.FontAlignment.BASELINE, slides.FontAlignment.TOP, slides.FontAlignment.CENTER, slides.FontAlignment.BOTTOM]
    font_sizes = [18, 36, 54]

    for i, alignment in enumerate(alignments):
        shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 30, 20 + i * 130, 660, 120)
        shape.fill_format.fill_type = slides.FillType.NO_FILL
        shape.line_format.fill_format.fill_type = slides.FillType.NO_FILL

        text_frame = shape.text_frame
        text_frame.text_frame_format.anchoring_type = slides.TextAnchorType.TOP
        text_frame.text_frame_format.autofit_type = slides.TextAutofitType.NONE
        text_frame.text_frame_format.wrap_text = slides.NullableBool.FALSE

        label = text_frame.paragraphs[0]
        label.text = alignment.name.title()
        label.paragraph_format.alignment = slides.TextAlignment.LEFT
        label.paragraph_format.default_portion_format.font_height = 14
        label.paragraph_format.default_portion_format.latin_font = slides.FontData("Arial")
        label.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
        label.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.gray

        paragraph = slides.Paragraph()
        paragraph.paragraph_format.font_alignment = alignment
        paragraph.paragraph_format.alignment = slides.TextAlignment.LEFT
        paragraph.paragraph_format.default_portion_format.latin_font = slides.FontData("Arial")
        paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
        paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black

        for font_size in font_sizes:
            portion = slides.Portion("Ag ")
            portion.portion_format.font_height = font_size
            paragraph.portions.add(portion)

        text_frame.paragraphs.add(paragraph)

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

Le résultat :

Comparaison de l’alignement de police Baseline, Haut, Centre et Bas avec des tailles de police mixtes

L’alignement de police utilise les métriques de police, de sorte que les bords visibles des lettres individuelles ne sont pas nécessairement parfaitement alignés. L’exemple comprend à la fois une lettre majuscule et un descendeur pour illustrer la différence entre l’alignement de base et l’alignement du bas. La disponibilité et le remplacement des polices, les caractères utilisés et la différence de tailles de police affectent le résultat. Les dimensions du cadre, les marges, l’espacement des lignes, le retour à la ligne et l’ajustement automatique influencent également la mise en page ; utilisez les mêmes polices et paramètres de mise en page lors de la comparaison des modes.

Ce réglage diffère de ParagraphFormat.alignment, qui contrôle l’alignement horizontal du paragraphe, et de TextFrameFormat.anchoring_type, qui positionne le bloc de texte verticalement à l’intérieur de sa forme. Le formatage exposant et indice via BasePortionFormat.escapement décale les portions individuelles par rapport à la ligne de base au lieu de définir l’alignement de police pour les lignes du paragraphe.

Définir la transparence du texte

La transparence du texte est contrôlée par le composant alpha de la couleur attribuée à BasePortionFormat.fill_format. Dans les exemples ci‑dessous, alpha = 50 est une valeur de canal alpha ARGB sur l’échelle 0–255, et non un pourcentage de transparence.

L’exemple de code ci-dessous montre comment appliquer la transparence au paragraphe entier :

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

alpha = 50

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    # Définir un remplissage noir semi-transparent pour le texte.
    paragraph.paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    paragraph.paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.from_argb(alpha, draw.Color.black)

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

Le résultat :

Le paragraphe transparent

L’exemple de code suivant montre comment appliquer la transparence aux portions de texte avec une police en gras :

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

alpha = 50

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    for portion in paragraph.portions:
        if portion.portion_format.get_effective().font_bold:
            # Définir la transparence de la portion de texte.
            portion.portion_format.fill_format.fill_type = slides.FillType.SOLID
            portion.portion_format.fill_format.solid_fill_color.color = draw.Color.from_argb(alpha, draw.Color.black)

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

Le résultat :

Les portions de texte transparentes

Définir l’espacement des caractères pour le texte

Utilisez BasePortionFormat.spacing pour élargir ou condenser l’espacement entre les caractères dans une zone de texte. Les exemples ajoutent 3 points d’espacement ; les valeurs négatives condensent le texte.

Le code Python suivant montre comment élargir l’espacement des caractères dans le paragraphe entier :

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    # Note : utilisez des valeurs négatives pour compresser l'espacement des caractères.
    paragraph.paragraph_format.default_portion_format.spacing = 3  # Étendre l'espacement des caractères.

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

Le résultat :

L’espacement des caractères dans le paragraphe

L’exemple de code ci‑dessous montre comment élargir l’espacement des caractères dans les portions de texte avec une police en gras :

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    for portion in paragraph.portions:
        if portion.portion_format.get_effective().font_bold:
            # Note : utilisez des valeurs négatives pour compresser l'espacement des caractères.
            portion.portion_format.spacing = 3  # Étendre l'espacement des caractères.

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

Le résultat :

L’espacement des caractères dans les portions de texte

Désactiver le crénage pour des polices spécifiques

Dans certains cas, le texte rendu par Aspose.Slides peut sembler légèrement plus serré que le même texte affiché dans PowerPoint. Cela peut se produire parce que PowerPoint peut ignorer les données de crénage pour certaines polices, même lorsque la police contient des informations de crénage valides et que le crénage est activé dans les paramètres de PowerPoint.

Pour rapprocher le rendu de celui de PowerPoint dans ces cas, vous pouvez désactiver le crénage pour les portions de texte qui utilisent la police concernée. Définissez BasePortionFormat.kerning_minimal_size sur une valeur supérieure à la taille réelle de la police. Cet exemple nécessite « presentation.pptx » avec une zone de texte comme première forme de la première diapositive. Il vérifie les noms de police effectifs, y compris les polices héritées, et fixe un seuil de 100 points pour les portions qui utilisent Roboto. Cela désactive le crénage pour les portions correspondantes dont la taille de police est inférieure à 100 points :

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]
    target_font = "Roboto"

    for paragraph in auto_shape.text_frame.paragraphs:
        for portion in paragraph.portions:
            text_format = portion.portion_format.get_effective()
            fonts = (text_format.latin_font, text_format.east_asian_font, text_format.complex_script_font)
            uses_target_font = any(font is not None and font.font_name == target_font for font in fonts)

            if uses_target_font:
                portion.portion_format.kerning_minimal_size = 100

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

Pour le texte correspondant en dessous du seuil, ce réglage empêche le crénage et peut aider à aligner le rendu d’Aspose.Slides avec la sortie visuelle de PowerPoint pour les polices affectées par ce comportement spécifique à PowerPoint.

Gérer les propriétés de police du texte

Les propriétés de police peuvent être définies au niveau du paragraphe via ParagraphFormat.default_portion_format ou sur des portions individuelles via PortionFormat.

L’exemple suivant définit la police par défaut du premier paragraphe sur Times New Roman 12 points avec formatage gras, italique et soulignement pointillé. Le formatage explicite sur les portions individuelles a la priorité sur ces valeurs par défaut.

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    # Définir les propriétés de police pour le paragraphe.
    portion_format = paragraph.paragraph_format.default_portion_format
    portion_format.font_height = 12
    portion_format.font_bold = slides.NullableBool.TRUE
    portion_format.font_italic = slides.NullableBool.TRUE
    portion_format.font_underline = slides.TextUnderlineType.DOTTED
    portion_format.latin_font = slides.FontData("Times New Roman")

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

Le résultat :

Les propriétés de police du paragraphe

L’exemple suivant applique Times New Roman 13 points, un formatage italique et un soulignement pointillé aux portions dont le formatage effectif est gras :

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    for portion in paragraph.portions:
        if portion.portion_format.get_effective().font_bold:
            # Définir les propriétés de police pour la portion de texte.
            portion.portion_format.font_height = 13
            portion.portion_format.font_italic = slides.NullableBool.TRUE
            portion.portion_format.font_underline = slides.TextUnderlineType.DOTTED
            portion.portion_format.latin_font = slides.FontData("Times New Roman")

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

Le résultat :

Les propriétés de police des portions de texte

Contrôler la normalisation de la hauteur du texte

Utilisez BasePortionFormat.normalise_height lors de la reproduction de la typographie d’un modèle ou de l’investigation des différences de hauteur de caractères. Dans PowerPoint, activer la normalisation étire ou compresse les caractères individuels verticalement afin de leur donner une hauteur visible uniforme au sein de la portion de texte. Cela ne garantit pas des hauteurs de texte égales entre différentes polices.

Définissez la propriété sur NullableBool.TRUE ou FALSE pour activer ou désactiver explicitement la normalisation. NullableBool.NOT_DEFINED laisse le réglage local non défini afin que la portion hérite de sa valeur, par exemple, du default_portion_format du paragraphe. Cela ne signifie pas False. Utilisez PortionFormat.get_effective et lisez IBasePortionFormatEffectiveData.normalise_height pour obtenir la valeur booléenne résolue.

L’exemple autonome suivant nécessite Arial installé. Il crée deux blocs de texte contenant les mêmes lettres majuscules, minuscules, descendeurs et caractères accentués en 54 points. Les deux paragraphes activent la normalisation par défaut. La portion supérieure la désactive explicitement ; la portion inférieure l’hérite. Les dimensions du cadre, les marges et l’espacement des paragraphes sont identiques, le retour à la ligne et l’ajustement automatique étant désactivés afin de garder la comparaison cohérente. L’exemple affiche FALSE: False et NOT_DEFINED: True, puis enregistre « text_height_normalization.pptx ».

import aspose.slides as slides

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

    settings = [slides.NullableBool.FALSE, slides.NullableBool.NOT_DEFINED]

    for i, setting in enumerate(settings):
        shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 30, 60 + i * 200, 660, 150)
        shape.fill_format.fill_type = slides.FillType.NO_FILL
        shape.line_format.fill_format.fill_type = slides.FillType.NO_FILL

        text_frame = shape.text_frame
        text_frame.text = "Hxgjpq ÅÉ 0123"
        text_frame.text_frame_format.autofit_type = slides.TextAutofitType.NONE
        text_frame.text_frame_format.wrap_text = slides.NullableBool.FALSE
        text_frame.text_frame_format.anchoring_type = slides.TextAnchorType.TOP
        text_frame.text_frame_format.margin_top = 0
        text_frame.text_frame_format.margin_left = 0

        paragraph = text_frame.paragraphs[0]
        paragraph.paragraph_format.alignment = slides.TextAlignment.LEFT
        paragraph.paragraph_format.space_before = 0
        paragraph.paragraph_format.space_after = 0
        paragraph.paragraph_format.space_within = 100
        paragraph.paragraph_format.default_portion_format.normalise_height = slides.NullableBool.TRUE

        portion = paragraph.portions[0]
        portion.portion_format.latin_font = slides.FontData("Arial")
        portion.portion_format.font_height = 54
        portion.portion_format.fill_format.fill_type = slides.FillType.SOLID
        portion.portion_format.fill_format.solid_fill_color.color = "black"
        portion.portion_format.normalise_height = setting

        print(f"{setting.name}: {portion.portion_format.get_effective().normalise_height}")

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

La comparaison ci‑dessous a été exportée depuis la présentation enregistrée. La ligne du haut a la normalisation désactivée (FALSE) ; la ligne du bas hérite du réglage activé (NOT_DEFINED → True). Gardez Arial installé pour reproduire cet aspect.

Texte Arial 54 points avec normalisation désactivée en haut et normalisation héritée activée en bas

La normalisation modifie la hauteur des caractères sans changer la valeur font_height assignée, qui spécifie la taille de la police en points. L'space_within du paragraphe contrôle l’espacement des lignes, tandis que autofit_type du cadre de texte contrôle comment le texte ou son conteneur s’ajuste pour tenir. Ces réglages servent à des fins différentes et peuvent affecter la mise en page globale de façon indépendante. Pour plus d’informations sur le formatage des paragraphes et l’héritage, voir Gérer les paragraphes.

Appliquer et supprimer le texte barré

Utilisez BasePortionFormat.strikethrough_type sur une portion de texte pour afficher des corrections, des termes annulés ou d’anciens prix sans supprimer le texte original. Réglez-le sur TextStrikethroughType.SINGLE ou DOUBLE pour une ou deux lignes traversant le texte.

Pour supprimer le texte barré, attribuez TextStrikethroughType.NONE. Cela désactive explicitement l’effet, même si le formatage environnant spécifie un texte barré. En revanche, TextStrikethroughType.NOT_DEFINED laisse le réglage local non défini, permettant à la portion d’hériter du formatage, par exemple du paragraphe. Cela ne garantit pas que le texte barré soit supprimé. Utilisez PortionFormat.get_effective pour lire le formatage résultant, y compris les valeurs héritées.

L’exemple autonome suivant crée trois comparaisons de prix. Chaque paragraphe possède des portions distinctes pour le libellé, l’ancien prix et le prix actuel, de sorte que seul l’ancien prix est affecté. La première ligne applique puis supprime le texte barré ; les autres lignes conservent respectivement le texte barré simple et double. Modifier cette propriété préserve le texte et les autres formats, y compris le gras de l’ancien prix.

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, 620, 220)
    shape.fill_format.fill_type = slides.FillType.NO_FILL
    shape.line_format.fill_format.fill_type = slides.FillType.NO_FILL
    shape.text_frame.paragraphs.clear()

    labels = ["None: ", "Single: ", "Double: "]

    for label in labels:
        paragraph = slides.Paragraph()
        paragraph.paragraph_format.alignment = slides.TextAlignment.LEFT
        paragraph.paragraph_format.space_after = 20

        portion_format = paragraph.paragraph_format.default_portion_format
        portion_format.font_height = 28
        portion_format.latin_font = slides.FontData("Arial")
        portion_format.fill_format.fill_type = slides.FillType.SOLID
        portion_format.fill_format.solid_fill_color.color = draw.Color.black

        paragraph.portions.add(slides.Portion(label))

        previous_price = slides.Portion("$100")
        previous_price.portion_format.font_bold = slides.NullableBool.TRUE
        paragraph.portions.add(previous_price)
        paragraph.portions.add(slides.Portion(" → $80"))

        shape.text_frame.paragraphs.add(paragraph)

    paragraphs = shape.text_frame.paragraphs

    # Appliquer le texte barré, puis le supprimer explicitement du premier prix précédent.
    paragraphs[0].portions[1].portion_format.strikethrough_type = slides.TextStrikethroughType.SINGLE
    paragraphs[0].portions[1].portion_format.strikethrough_type = slides.TextStrikethroughType.NONE

    paragraphs[1].portions[1].portion_format.strikethrough_type = slides.TextStrikethroughType.SINGLE
    paragraphs[2].portions[1].portion_format.strikethrough_type = slides.TextStrikethroughType.DOUBLE

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

Le résultat, de haut en bas : aucun texte barré, texte barré simple, texte barré double.

Anciens prix sans texte barré, avec texte barré simple et avec texte barré double

Définir la rotation du texte

Utilisez TextFrameFormat.text_vertical_type pour définir une orientation de texte prédéfinie à l’intérieur d’une forme.

L’exemple de code suivant définit l’orientation du texte dans la forme sur TextVerticalType.VERTICAL270, qui fait pivoter le texte de 90 degrés dans le sens inverse des aiguilles d’une montre :

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]

    auto_shape.text_frame.text_frame_format.text_vertical_type = slides.TextVerticalType.VERTICAL270

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

Le résultat :

La rotation du texte

Définir une rotation personnalisée pour les cadres de texte

Utilisez TextFrameFormat.rotation_angle pour définir un angle de rotation personnalisé pour un TextFrame.

L’exemple de code ci‑dessus tourne le cadre de texte de 3 degrés dans le sens des aiguilles d’une montre au sein de la forme :

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]

    auto_shape.text_frame.text_frame_format.rotation_angle = 3

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

Le résultat :

La rotation personnalisée du texte

Définir l’espacement des lignes des paragraphes

Aspose.Slides fournit ParagraphFormat.space_after, ParagraphFormat.space_before et ParagraphFormat.space_within pour contrôler l’espacement des paragraphes. Ces propriétés sont utilisées comme suit :

  • Utilisez une valeur positive pour spécifier l’espacement des lignes en pourcentage de la hauteur de ligne.
  • Utilisez une valeur négative pour spécifier l’espacement des lignes en points.

L’exemple suivant définit l’espacement à l’intérieur du premier paragraphe à 200 % de la hauteur de ligne (double interligne) :

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    paragraph.paragraph_format.space_within = 200

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

Le résultat :

L’espacement des lignes à l’intérieur du paragraphe

Contrôler le retour à la ligne

Les règles de retour à la ligne des paragraphes sont utiles dans les blocs de texte étroits et les présentations qui mélangent du texte latin et asiatique de l’Est. Les propriétés suivantes appartiennent à ParagraphFormat, elles s’appliquent donc à un paragraphe entier :

  • latin_line_break contrôle les règles de retour à la ligne pour le texte latin. Dans un texte mixte, le modifier peut aussi changer l’endroit où le texte asiatique de l’Est adjacent et la ponctuation se renvoient.
  • east_asian_line_break contrôle les règles de retour à la ligne pour le texte asiatique de l’Est, y compris les restrictions sur les caractères en début et fin de ligne.

Ces règles ne remplacent pas TextFrameFormat.wrap_text, qui active le retour à la ligne automatique dans un cadre de texte. Elles influencent la mise en page lorsque le retour à la ligne se produit ; elles n’insèrent pas de caractères de retour à la ligne. Un retour à la ligne explicite force une nouvelle ligne dans le paragraphe indépendamment de la largeur disponible.

L’exemple autonome suivant crée un bloc de texte étroit contenant du chinois et du texte latin. Il définit explicitement les deux propriétés de retour à la ligne et enregistre « line_breaking.pptx ». Pour expérimenter avec l’une ou l’autre règle, modifiez la valeur de cette propriété tout en maintenant les autres réglages fixes. L’exemple utilise Arial 24 points et SimSun avec une largeur de cadre de 160 points et des marges horizontales du cadre de texte à zéro. TextFrameFormat.autofit_type est réglé sur TextAutofitType.NONE afin que la taille du texte et les dimensions du cadre restent fixes.

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, 160, 300)
    shape.fill_format.fill_type = slides.FillType.NO_FILL

    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
    text_frame.text_frame_format.margin_left = 0
    text_frame.text_frame_format.margin_right = 0

    paragraph = text_frame.paragraphs[0]
    paragraph.text = "中文排版测试,PowerPoint 中文演示。"

    paragraph_format = paragraph.paragraph_format
    paragraph_format.alignment = slides.TextAlignment.LEFT
    paragraph_format.default_portion_format.font_height = 24
    paragraph_format.default_portion_format.latin_font = slides.FontData("Arial")
    paragraph_format.default_portion_format.east_asian_font = slides.FontData("SimSun")
    paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    paragraph_format.latin_line_break = slides.NullableBool.FALSE
    paragraph_format.east_asian_line_break = slides.NullableBool.TRUE

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

Contrôler la ponctuation en suspension

ParagraphFormat.hanging_punctuation permet à la ponctuation admissible de dépasser le bord droit de la ligne de texte au lieu d’occuper la ligne suivante. Elle s’applique à tout le paragraphe et diffère d’un retrait suspendu.

L’exemple autonome suivant active la ponctuation en suspension dans un cadre de texte de 100 points de largeur et enregistre « hanging_punctuation.pptx ». Avec Arial 24 points et des marges horizontales du cadre de texte à zéro, le point final reste après le mot « sentence » et dépasse le bord droit du texte. Réglez la propriété sur NullableBool.FALSE pour comparer : avec ces réglages, le point occupe une ligne séparée. Le retour à la ligne est activé et l’ajustement automatique désactivé afin de garder la largeur disponible fixe.

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, 100, 200)
    shape.fill_format.fill_type = slides.FillType.NO_FILL

    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
    text_frame.text_frame_format.margin_left = 0
    text_frame.text_frame_format.margin_right = 0

    paragraph = text_frame.paragraphs[0]
    paragraph.text = "Simple text, next sentence."

    paragraph_format = paragraph.paragraph_format
    paragraph_format.alignment = slides.TextAlignment.LEFT
    paragraph_format.default_portion_format.font_height = 24
    paragraph_format.default_portion_format.latin_font = slides.FontData("Arial")
    paragraph_format.default_portion_format.fill_format.fill_type = slides.FillType.SOLID
    paragraph_format.default_portion_format.fill_format.solid_fill_color.color = draw.Color.black
    paragraph_format.hanging_punctuation = slides.NullableBool.TRUE

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

Toutes les marques de ponctuation ne peuvent pas être suspendues. Le résultat visible dépend des conditions de police et de mise en page : changer la police, la largeur disponible, les marges ou les réglages d’ajustement peut éliminer la différence visible.

Définir le type d’ajustement automatique pour les cadres de texte

TextFrameFormat.autofit_type détermine comment le texte se comporte lorsqu’il dépasse les limites de son conteneur. Utilisez-le pour contrôler si le texte se réduit, déborde ou redimensionne automatiquement la forme. L’exemple suivant configure la forme pour qu’elle redimensionne afin de s’adapter à son texte et enregistre le résultat sous « autofit_type.pptx ».

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]

    auto_shape.text_frame.text_frame_format.autofit_type = slides.TextAutofitType.SHAPE

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

Pour compter les lignes après le retour à la ligne automatique et voir comment le texte ou la largeur de la forme modifie le résultat, voir Count Rendered Lines. Le nombre de lignes seul n’indique pas si le texte déborde de son conteneur.

Définir l’ancrage des cadres de texte

TextFrameFormat.anchoring_type définit comment le texte est positionné verticalement à l’intérieur d’une forme, par exemple en haut, au milieu ou en bas. L’exemple suivant ancre le texte en bas de la première forme et enregistre le résultat sous « text_anchor.pptx ».

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]

    auto_shape.text_frame.text_frame_format.anchoring_type = slides.TextAnchorType.BOTTOM

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

Définir la tabulation du texte

Utilisez ParagraphFormat.default_tab_size et ParagraphFormat.tabs pour configurer les tabulations dans un paragraphe. L’exemple suivant définit l’intervalle de tabulation par défaut sur 100 points et ajoute une tabulation alignée à gauche à 30 points. Ces réglages affectent le texte contenant des caractères de tabulation.

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]
    paragraph = auto_shape.text_frame.paragraphs[0]

    paragraph.paragraph_format.default_tab_size = 100
    paragraph.paragraph_format.tabs.add(30, slides.TabAlignment.LEFT)

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

Le résultat :

Les tabulations du paragraphe

Définir la langue de vérification

Aspose.Slides fournit BasePortionFormat.language_id, qui permet de définir la langue de vérification pour une portion de texte. La langue de vérification détermine la langue utilisée pour les vérifications orthographiques et grammaticales dans PowerPoint.

L’exemple suivant nécessite « presentation.pptx » avec une zone de texte comme première forme de la première diapositive et au moins un paragraphe. Il remplace le contenu du premier paragraphe par « 1。 », définit SimSun comme police et attribue la langue de vérification Simplifiée chinoise (zh-CN). Il enregistre le résultat sous « proofing_language.pptx »:

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]

    paragraph = auto_shape.text_frame.paragraphs[0]
    paragraph.portions.clear()

    font = slides.FontData("SimSun")

    text_portion = slides.Portion()
    text_portion.portion_format.complex_script_font = font
    text_portion.portion_format.east_asian_font = font
    text_portion.portion_format.latin_font = font

    # Définir la langue de vérification en chinois simplifié.
    text_portion.portion_format.language_id = "zh-CN"

    text_portion.text = "1。"
    paragraph.portions.add(text_portion)

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

Copier les métadonnées de langue

Lors de la copie de texte multilingue depuis un modèle, conservez à la fois BasePortionFormat.language_id et BasePortionFormat.alternative_language_id. L’exemple autonome suivant crée une portion source avec l’anglais américain comme langue et le français comme langue alternative, puis copie le texte et les identifiants vers une portion dans une nouvelle présentation.

import aspose.slides as slides

source = slides.Portion("Hello! Bonjour!")
source.portion_format.language_id = "en-US"
source.portion_format.alternative_language_id = "fr-FR"

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

    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 20, 20, 400, 80)
    paragraph = shape.text_frame.paragraphs[0]
    paragraph.portions.clear()

    destination = slides.Portion()
    destination.text = source.text
    destination.portion_format.language_id = source.portion_format.language_id
    # Si la source n'a pas de langue alternative, None supprime la valeur de destination.
    destination.portion_format.alternative_language_id = source.portion_format.alternative_language_id
    paragraph.portions.add(destination)

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

Pour essayer une source sans langue alternative, omettez l’affectation de "fr-FR". L’identifiant alternatif devient alors None, et la même instruction de copie préserve son absence sans introduire une valeur par défaut, même si la destination avait précédemment une langue alternative assignée.

Ces identifiants sont stockés comme métadonnées de langue. Les conserver n’établit pas quel dictionnaire PowerPoint sélectionne pour les vérifications orthographiques ou grammaticales.

Définir la langue par défaut

Utilisez LoadOptions.default_text_language pour définir la langue par défaut du texte créé lors du chargement ou de la création d’une présentation. L’exemple suivant crée une présentation avec l’anglais américain comme langue de texte par défaut, ajoute une zone de texte et affiche en-US pour sa première portion de texte.

import aspose.slides as slides

load_options = slides.LoadOptions()
load_options.default_text_language = "en-US"

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

    # Ajouter une nouvelle forme rectangulaire avec du texte.
    shape = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 20, 20, 150, 50)
    shape.text_frame.text = "Sample text"

    # Vérifier la langue de la première portion.
    portion = shape.text_frame.paragraphs[0].portions[0]
    print(portion.portion_format.language_id)

Définir le style de texte par défaut

Pour appliquer un formatage de texte par défaut au niveau de la présentation, utilisez Presentation.default_text_style.

L’exemple suivant définit une police en gras de 14 points comme valeur par défaut pour les paragraphes de niveau supérieur dans une nouvelle présentation et l’enregistre sous « default_text_style.pptx ». Le texte peut hériter de ces valeurs par défaut à moins qu’un formatage plus spécifique ne les surcharge.

import aspose.slides as slides

with slides.Presentation() as presentation:
    # Obtenir le format de paragraphe de niveau supérieur.
    paragraph_format = presentation.default_text_style.get_level(0)

    if paragraph_format is not None:
        paragraph_format.default_portion_format.font_height = 14
        paragraph_format.default_portion_format.font_bold = slides.NullableBool.TRUE

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

Extraire le texte avec l’effet majuscules

Dans PowerPoint, appliquer l’effet de police All Caps fait apparaître le texte en majuscules sur la diapositive même s’il a été saisi initialement en minuscules. Lorsque vous récupérez une telle portion de texte avec Aspose.Slides, la bibliothèque renvoie le texte exactement tel qu’il a été entré. Pour correspondre au texte affiché, vérifiez TextCapType et convertissez la chaîne retournée en majuscules lorsque la valeur est ALL.

Cet exemple nécessite « sample2.pptx » avec une zone de texte comme première forme de la première diapositive. La première portion du premier paragraphe contient « Hello, Aspose! » avec l’effet All Caps appliqué, comme illustré ci‑dessous.

L’effet All Caps

L’exemple de code ci‑dessous montre comment extraire le texte avec l’effet All Caps appliqué :

import aspose.slides as slides

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

    auto_shape = slide.shapes[0]
    text_portion = auto_shape.text_frame.paragraphs[0].portions[0]

    print("Original text:", text_portion.text)

    text_format = text_portion.portion_format.get_effective()
    if text_format.text_cap_type == slides.TextCapType.ALL:
        text = text_portion.text.upper()
        print("All-Caps effect:", text)

Sortie :

Original text: Hello, Aspose!
All-Caps effect: HELLO, ASPOSE!

FAQ

Comment modifier le texte dans un tableau sur une diapositive ?

Pour modifier le texte dans un tableau sur une diapositive, utilisez Table. Parcourez les cellules et mettez à jour chaque cellule via Cell.text_frame et le formatage des paragraphes via Paragraph.paragraph_format.

Comment appliquer une couleur dégradée au texte sur une diapositive PowerPoint ?

Pour appliquer une couleur dégradée au texte, utilisez BasePortionFormat.fill_format. Réglez FillFormat.fill_type sur FillType.GRADIENT et configurez les arrêts du dégradé, la direction et la transparence.

Fonctionnalité associée : Formater le texte dans les diapositives.