Formater le texte d'une présentation en Python via Java
Vue d’ensemble
Cet article montre comment mettre en forme du texte dans les présentations PowerPoint et OpenDocument à l’aide d’Aspose.Slides for Python via Java. Il couvre les couleurs d’arrière‑plan, la transparence, l’espacement des caractères, les propriétés des polices, la rotation, l’espacement des paragraphes, le comportement d’ajustement automatique, l’ancrage du texte, les taquets de tabulation 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 en gras hérité :

Pour rechercher et mettre en surbrillance du texte littéral ou des correspondances d’expression régulière, voir Search and Replace Text.
Définir la couleur d’arrière-plan du texte
Utilisez ParagraphFormat.getDefaultPortionFormat pour définir la couleur de surbrillance par défaut d’un paragraphe, ou utilisez BasePortionFormat.getHighlightColor pour des portions de texte individuelles.
L’exemple suivant définit une surbrillance gris clair comme valeur par défaut du premier paragraphe. Les couleurs de surbrillance explicites sur les portions individuelles ont la priorité sur cette valeur par défaut :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat
from java.awt import Color
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
# Définir la couleur de surbrillance pour l'ensemble du paragraphe.
paragraph.getParagraphFormat().getDefaultPortionFormat().getHighlightColor().setColor(Color.LIGHT_GRAY)
presentation.save("gray_paragraph.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

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 jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat
from java.awt import Color
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
for portion in paragraph.getPortions():
if portion.getPortionFormat().getEffective().getFontBold():
# Définir la couleur de surbrillance pour la portion de texte.
portion.getPortionFormat().getHighlightColor().setColor(Color.LIGHT_GRAY)
presentation.save("gray_text_portions.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

Aligner les paragraphes de texte
Utilisez ParagraphFormat.setAlignment pour définir l’alignement du paragraphe dans 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 jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat, TextAlignment
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
# Définir l'alignement du paragraphe au centre.
paragraph.getParagraphFormat().setAlignment(TextAlignment.Center)
presentation.save("aligned_paragraph.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

Aligner les polices dans une ligne
Utilisez ParagraphFormat.setFontAlignment pour aligner verticalement les portions de texte de différentes tailles de police au sein d’une ligne. Ce paramètre s’applique à l’ensemble du paragraphe et contrôle l’alignement dans 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 renvoi à la ligne, et garde les cadres de texte suffisamment grands pour une seule ligne.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FillType, FontAlignment, FontData, NullableBool, Paragraph, Portion, Presentation, SaveFormat, ShapeType, TextAlignment, TextAnchorType, TextAutofitType
from java.awt import Color
presentation = Presentation()
try:
slide = presentation.getSlides().get_Item(0)
alignments = [FontAlignment.Baseline, FontAlignment.Top, FontAlignment.Center, FontAlignment.Bottom]
alignment_names = ["Baseline", "Top", "Center", "Bottom"]
font_sizes = [18.0, 36.0, 54.0]
font = FontData("Arial")
for i, alignment in enumerate(alignments):
shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 30, 20 + i * 130, 660, 120)
shape.getFillFormat().setFillType(FillType.NoFill)
shape.getLineFormat().getFillFormat().setFillType(FillType.NoFill)
text_frame = shape.getTextFrame()
text_frame.getTextFrameFormat().setAnchoringType(TextAnchorType.Top)
text_frame.getTextFrameFormat().setAutofitType(TextAutofitType.None_)
text_frame.getTextFrameFormat().setWrapText(NullableBool.False_)
label = text_frame.getParagraphs().get_Item(0)
label.setText(alignment_names[i])
label.getParagraphFormat().setAlignment(TextAlignment.Left)
label.getParagraphFormat().getDefaultPortionFormat().setFontHeight(14)
label.getParagraphFormat().getDefaultPortionFormat().setLatinFont(font)
label.getParagraphFormat().getDefaultPortionFormat().getFillFormat().setFillType(FillType.Solid)
label.getParagraphFormat().getDefaultPortionFormat().getFillFormat().getSolidFillColor().setColor(Color.GRAY)
paragraph = Paragraph()
paragraph.getParagraphFormat().setFontAlignment(alignment)
paragraph.getParagraphFormat().setAlignment(TextAlignment.Left)
paragraph.getParagraphFormat().getDefaultPortionFormat().setLatinFont(font)
paragraph.getParagraphFormat().getDefaultPortionFormat().getFillFormat().setFillType(FillType.Solid)
paragraph.getParagraphFormat().getDefaultPortionFormat().getFillFormat().getSolidFillColor().setColor(Color.BLACK)
for font_size in font_sizes:
portion = Portion("Ag ")
portion.getPortionFormat().setFontHeight(font_size)
paragraph.getPortions().add(portion)
text_frame.getParagraphs().add(paragraph)
presentation.save("font_alignment.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

L’alignement de police utilise les métriques de police, de sorte que les bords visibles des lettres individuelles ne s’alignent pas toujours exactement. L’exemple inclut une lettre majuscule et un descendant pour illustrer la différence entre l’alignement de ligne de base et celui en bas. La disponibilité des polices, la substitution, les caractères utilisés et les différences de tailles de police influencent le résultat. La taille du cadre, les marges, l’interlignage, le renvoi à la ligne et l’ajustement automatique affectent également la disposition ; utilisez les mêmes polices et paramètres de mise en page pour comparer les modes.
Ce paramètre diffère de ParagraphFormat.setAlignment, qui contrôle l’alignement horizontal du paragraphe, et de TextFrameFormat.setAnchoringType, qui positionne le bloc de texte verticalement dans sa forme. La mise en forme exposant et indice via BasePortionFormat.setEscapement décale les portions individuelles par rapport à la ligne de base plutôt que 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 assignée à BasePortionFormat.getFillFormat. Dans les exemples ci‑dessous, alpha = 50 est une valeur de canal alpha ARGB sur une échelle de 0 à 255, pas un pourcentage de transparence.
L’exemple de code suivant montre comment appliquer la transparence à l’ensemble du paragraphe :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FillType, Presentation, SaveFormat
from java.awt import Color
alpha = 50
text_color = Color(0, 0, 0, alpha)
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
# Définir la couleur de remplissage du texte à une couleur transparente.
paragraph.getParagraphFormat().getDefaultPortionFormat().getFillFormat().setFillType(FillType.Solid)
paragraph.getParagraphFormat().getDefaultPortionFormat().getFillFormat().getSolidFillColor().setColor(text_color)
presentation.save("transparent_paragraph.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

L’exemple de code suivant montre comment appliquer la transparence à les portions de texte avec une police en gras :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FillType, Presentation, SaveFormat
from java.awt import Color
alpha = 50
text_color = Color(0, 0, 0, alpha)
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
for portion in paragraph.getPortions():
if portion.getPortionFormat().getEffective().getFontBold():
# Définir la transparence de la portion de texte.
portion.getPortionFormat().getFillFormat().setFillType(FillType.Solid)
portion.getPortionFormat().getFillFormat().getSolidFillColor().setColor(text_color)
presentation.save("transparent_text_portions.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

Définir l’espacement des caractères pour le texte
Utilisez BasePortionFormat.setSpacing pour élargir ou réduire 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 augmenter l’espacement des caractères dans l’ensemble du paragraphe :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
# Remarque : utilisez des valeurs négatives pour compresser l'espacement des caractères.
paragraph.getParagraphFormat().getDefaultPortionFormat().setSpacing(3) # Étendre l'espacement des caractères.
presentation.save("character_spacing_in_paragraph.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

L’exemple de code ci‑dessous montre comment augmenter l’espacement des caractères dans les portions de texte avec une police en gras :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
for portion in paragraph.getPortions():
if portion.getPortionFormat().getEffective().getFontBold():
# Remarque : utilisez des valeurs négatives pour compresser l'espacement des caractères.
portion.getPortionFormat().setSpacing(3) # Étendre l'espacement des caractères.
presentation.save("character_spacing_in_text_portions.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

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 ignore 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.setKerningMinimalSize à 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 sur la première diapositive. Il vérifie les noms de polices effectifs, y compris les polices héritées, et définit 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 jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
target_font = "Roboto"
for paragraph in auto_shape.getTextFrame().getParagraphs():
for portion in paragraph.getPortions():
portion_format = portion.getPortionFormat().getEffective()
fonts = (portion_format.getLatinFont(), portion_format.getEastAsianFont(), portion_format.getComplexScriptFont())
if any(font is not None and font.getFontName() == target_font for font in fonts):
portion.getPortionFormat().setKerningMinimalSize(100)
presentation.save("output.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Pour le texte correspondant en dessous du seuil, ce paramètre 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 propre à 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.getDefaultPortionFormat ou sur des portions individuelles via PortionFormat.
L’exemple suivant définit la police par défaut du premier paragraphe à Times New Roman 12 pt avec gras, italique et soulignement pointillé. Le formatage explicite sur les portions individuelles a la priorité sur ces valeurs par défaut.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FontData, NullableBool, Presentation, SaveFormat, TextUnderlineType
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
# Définir les propriétés de police du paragraphe.
paragraph.getParagraphFormat().getDefaultPortionFormat().setFontHeight(12)
paragraph.getParagraphFormat().getDefaultPortionFormat().setFontBold(NullableBool.True_)
paragraph.getParagraphFormat().getDefaultPortionFormat().setFontItalic(NullableBool.True_)
paragraph.getParagraphFormat().getDefaultPortionFormat().setFontUnderline(TextUnderlineType.Dotted)
font = FontData("Times New Roman")
paragraph.getParagraphFormat().getDefaultPortionFormat().setLatinFont(font)
presentation.save("font_properties_for_paragraph.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

L’exemple suivant applique Times New Roman 13 pt, un formatage italique et un soulignement pointillé aux portions dont le formatage effectif est gras :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FontData, NullableBool, Presentation, SaveFormat, TextUnderlineType
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
for portion in paragraph.getPortions():
if portion.getPortionFormat().getEffective().getFontBold():
# Définir les propriétés de police pour la portion de texte.
portion.getPortionFormat().setFontHeight(13)
portion.getPortionFormat().setFontItalic(NullableBool.True_)
portion.getPortionFormat().setFontUnderline(TextUnderlineType.Dotted)
font = FontData("Times New Roman")
portion.getPortionFormat().setLatinFont(font)
presentation.save("font_properties_for_text_portions.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

Contrôler la normalisation de la hauteur du texte
Utilisez BasePortionFormat.setNormaliseHeight lors de la reproduction de typographies de modèle ou de l’étude des différences de hauteur de caractère. Dans PowerPoint, l’activation de la normalisation étire ou compresse verticalement les caractères individuels afin qu’ils aient une hauteur visible uniforme au sein de la portion de texte. Cela ne garantit pas une hauteur identique entre différentes polices.
Définissez la propriété sur NullableBool.True_ or False_ pour activer ou désactiver explicitement la normalisation. NullableBool.NotDefined laisse le paramètre local non défini afin que la portion hérite de la valeur du paragraphe via getDefaultPortionFormat. Ce n’est pas équivalent à False. Utilisez PortionFormat.getEffective et lisez getNormaliseHeight sur le formatage effectif retourné 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, descendants et caractères accentués en 54 pt. Les deux paragraphes activent la normalisation par défaut. La partie supérieure désactive explicitement la normalisation ; la partie inférieure l’hérite. Les tailles de cadre, marges et espacement des paragraphes sont identiques, le renvoi à la ligne et l’ajustement automatique sont désactivés pour garder la comparaison cohérente. L’exemple affiche False: False et NotDefined: True, puis enregistre « text_height_normalization.pptx ».
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FillType, FontData, NullableBool, Presentation, SaveFormat, ShapeType, TextAlignment, TextAnchorType, TextAutofitType
from java.awt import Color
presentation = Presentation()
try:
slide = presentation.getSlides().get_Item(0)
settings = [NullableBool.False_, NullableBool.NotDefined]
setting_names = ["False", "NotDefined"]
for i, setting in enumerate(settings):
shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 30, 60 + i * 200, 660, 150)
shape.getFillFormat().setFillType(FillType.NoFill)
shape.getLineFormat().getFillFormat().setFillType(FillType.NoFill)
text_frame = shape.getTextFrame()
text_frame.setText("Hxgjpq ÅÉ 0123")
text_frame.getTextFrameFormat().setAutofitType(TextAutofitType.None_)
text_frame.getTextFrameFormat().setWrapText(NullableBool.False_)
text_frame.getTextFrameFormat().setAnchoringType(TextAnchorType.Top)
text_frame.getTextFrameFormat().setMarginTop(0)
text_frame.getTextFrameFormat().setMarginLeft(0)
paragraph = text_frame.getParagraphs().get_Item(0)
paragraph.getParagraphFormat().setAlignment(TextAlignment.Left)
paragraph.getParagraphFormat().setSpaceBefore(0)
paragraph.getParagraphFormat().setSpaceAfter(0)
paragraph.getParagraphFormat().setSpaceWithin(100)
paragraph.getParagraphFormat().getDefaultPortionFormat().setNormaliseHeight(NullableBool.True_)
portion = paragraph.getPortions().get_Item(0)
font = FontData("Arial")
portion.getPortionFormat().setLatinFont(font)
portion.getPortionFormat().setFontHeight(54)
portion.getPortionFormat().getFillFormat().setFillType(FillType.Solid)
portion.getPortionFormat().getFillFormat().getSolidFillColor().setColor(Color.BLACK)
portion.getPortionFormat().setNormaliseHeight(setting)
print(f"{setting_names[i]}: {bool(portion.getPortionFormat().getEffective().getNormaliseHeight())}")
presentation.save("text_height_normalization.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
La comparaison ci‑dessous a été exportée depuis la présentation enregistrée. La ligne supérieure a la normalisation désactivée (False) ; la ligne inférieure l’hérite (NotDefined → True). Gardez Arial installé pour reproduire cet aspect.

La normalisation modifie la hauteur des caractères sans changer la valeur assignée à getFontHeight, qui spécifie la taille de police en points. ParagraphFormat.setSpaceWithin contrôle l’interlignage, tandis que TextFrameFormat.setAutofitType contrôle la façon dont le texte ou son conteneur s’ajuste. Ces réglages répondent à des besoins différents et peuvent affecter la mise en page de façon indépendante. Pour plus d’informations sur le formatage des paragraphes et l’héritage, voir Manage Paragraph.
Appliquer et supprimer le barré
Utilisez BasePortionFormat.setStrikethroughType sur une portion de texte pour afficher des corrections, des termes annulés ou des anciens prix sans supprimer le texte d’origine. Définissez-le sur TextStrikethroughType.Single or Double pour une ou deux lignes traversant le texte.
Pour supprimer le barré, utilisez TextStrikethroughType.None_. Cela désactive explicitement l’effet, même si le formatage environnant spécifie le barré. En revanche, TextStrikethroughType.NotDefined laisse le paramètre local indéfini, permettant à la portion d’hériter du formatage, par exemple du paragraphe. Cela ne garantit pas que le barré soit supprimé. Utilisez PortionFormat.getEffective 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 barré ; les autres lignes conservent le barré simple et double. Modifier ce paramètre préserve le texte et ses autres formats, y compris le gras de l’ancien prix.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FillType, FontData, NullableBool, Paragraph, Portion, Presentation, SaveFormat, ShapeType, TextAlignment, TextStrikethroughType
from java.awt import Color
presentation = Presentation()
try:
slide = presentation.getSlides().get_Item(0)
shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 50, 50, 620, 220)
shape.getFillFormat().setFillType(FillType.NoFill)
shape.getLineFormat().getFillFormat().setFillType(FillType.NoFill)
shape.getTextFrame().getParagraphs().clear()
labels = ["None: ", "Single: ", "Double: "]
for label in labels:
paragraph = Paragraph()
paragraph.getParagraphFormat().setAlignment(TextAlignment.Left)
paragraph.getParagraphFormat().setSpaceAfter(20)
portion_format = paragraph.getParagraphFormat().getDefaultPortionFormat()
portion_format.setFontHeight(28)
font = FontData("Arial")
portion_format.setLatinFont(font)
portion_format.getFillFormat().setFillType(FillType.Solid)
portion_format.getFillFormat().getSolidFillColor().setColor(Color.BLACK)
label_portion = Portion(label)
paragraph.getPortions().add(label_portion)
previous_price = Portion("$100")
previous_price.getPortionFormat().setFontBold(NullableBool.True_)
paragraph.getPortions().add(previous_price)
current_price = Portion(" → $80")
paragraph.getPortions().add(current_price)
shape.getTextFrame().getParagraphs().add(paragraph)
paragraphs = shape.getTextFrame().getParagraphs()
# Appliquer le barré, puis le supprimer explicitement du premier prix précédent.
paragraphs.get_Item(0).getPortions().get_Item(1).getPortionFormat().setStrikethroughType(TextStrikethroughType.Single)
paragraphs.get_Item(0).getPortions().get_Item(1).getPortionFormat().setStrikethroughType(TextStrikethroughType.None_)
paragraphs.get_Item(1).getPortions().get_Item(1).getPortionFormat().setStrikethroughType(TextStrikethroughType.Single)
paragraphs.get_Item(2).getPortions().get_Item(1).getPortionFormat().setStrikethroughType(TextStrikethroughType.Double)
presentation.save("strikethrough.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat, de haut en bas : aucun barré, barré simple et barré double.

Définir la rotation du texte
Utilisez TextFrameFormat.setTextVerticalType pour définir une orientation de texte prédéfinie dans une forme.
L’exemple de code suivant définit l’orientation du texte dans la forme sur TextVerticalType.Vertical270, ce qui fait pivoter le texte de 90 degrés dans le sens inverse des aiguilles d’une montre :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat, TextVerticalType
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
auto_shape.getTextFrame().getTextFrameFormat().setTextVerticalType(TextVerticalType.Vertical270)
presentation.save("text_rotation.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

Définir une rotation personnalisée pour les cadres de texte
Utilisez TextFrameFormat.setRotationAngle pour définir un angle de rotation personnalisé pour un TextFrame.
L’exemple de code ci‑dess dessous fait pivoter le cadre de texte de 3 degrés dans le sens des aiguilles d’une montre à l’intérieur de la forme :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
auto_shape.getTextFrame().getTextFrameFormat().setRotationAngle(3)
presentation.save("custom_text_rotation.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

Définir l’interlignage des paragraphes
Aspose.Slides fournit ParagraphFormat.setSpaceAfter, ParagraphFormat.setSpaceBefore et ParagraphFormat.setSpaceWithin pour contrôler l’espacement des paragraphes. Ces propriétés sont utilisées comme suit :
- Utilisez une valeur positive pour spécifier l’interlignage en pourcentage de la hauteur de ligne.
- Utilisez une valeur négative pour spécifier l’interlignage en points.
L’exemple suivant fixe l’espacement à l’intérieur du premier paragraphe à 200 % de la hauteur de ligne (interlignage double) :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
paragraph.getParagraphFormat().setSpaceWithin(200)
presentation.save("line_spacing.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

Contrôler le retour à la ligne
Les règles de retour à la ligne des paragraphes sont utiles dans des blocs de texte étroits et des présentations qui mêlent du texte latin et est‑asiatique. Les méthodes suivantes appartiennent à ParagraphFormat, elles s’appliquent donc à un paragraphe entier :
- setLatinLineBreak contrôle les règles de retour à la ligne latin. Dans un texte mixte, le modifier peut aussi changer l’endroit où le texte est‑asiatique voisin et la ponctuation se renvoient.
- setEastAsianLineBreak contrôle les règles de retour à la ligne est‑asiatiques, y compris les restrictions sur les caractères en début ou fin de ligne.
Ces règles ne remplacent pas TextFrameFormat.setWrapText, qui active le renvoi à la ligne automatique dans un cadre de texte. Elles influencent la mise en page lorsque le renvoi à la ligne se produit ; elles n’insèrent pas de caractères de saut de ligne. Un saut de 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 latin. Il définit explicitement les deux options de retour à la ligne et enregistre « line_breaking.pptx ». Pour expérimenter avec l’une ou l’autre règle, modifiez la valeur correspondante tout en maintenant l’autre paramètre fixe. L’exemple utilise Arial 24 pt et SimSun avec une largeur de cadre de 160 pt et des marges horizontales du cadre de texte à zéro. TextFrameFormat.setAutofitType est appelé avec TextAutofitType.None_ afin que la taille du texte et les dimensions du cadre restent fixes.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FillType, FontData, NullableBool, Presentation, SaveFormat, ShapeType, TextAlignment, TextAutofitType
from java.awt import Color
presentation = Presentation()
try:
slide = presentation.getSlides().get_Item(0)
shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 50, 50, 160, 300)
shape.getFillFormat().setFillType(FillType.NoFill)
text_frame = shape.getTextFrame()
text_frame.getTextFrameFormat().setWrapText(NullableBool.True_)
text_frame.getTextFrameFormat().setAutofitType(TextAutofitType.None_)
text_frame.getTextFrameFormat().setMarginLeft(0)
text_frame.getTextFrameFormat().setMarginRight(0)
paragraph = text_frame.getParagraphs().get_Item(0)
paragraph.setText("中文排版测试,PowerPoint 中文演示。")
paragraph_format = paragraph.getParagraphFormat()
paragraph_format.setAlignment(TextAlignment.Left)
paragraph_format.getDefaultPortionFormat().setFontHeight(24)
latin_font = FontData("Arial")
paragraph_format.getDefaultPortionFormat().setLatinFont(latin_font)
east_asian_font = FontData("SimSun")
paragraph_format.getDefaultPortionFormat().setEastAsianFont(east_asian_font)
paragraph_format.getDefaultPortionFormat().getFillFormat().setFillType(FillType.Solid)
paragraph_format.getDefaultPortionFormat().getFillFormat().getSolidFillColor().setColor(Color.BLACK)
paragraph_format.setLatinLineBreak(NullableBool.False_)
paragraph_format.setEastAsianLineBreak(NullableBool.True_)
presentation.save("line_breaking.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Contrôler la ponctuation en suspension
ParagraphFormat.setHangingPunctuation permet à la ponctuation admissible de dépasser le bord droit de la ligne de texte plutôt que d’occuper la ligne suivante. Elle s’applique à l’ensemble du paragraphe et diffère d’un retrait suspendu.
L’exemple autonome suivant active la ponctuation en suspension dans un cadre de texte de 100 pt de large et enregistre « hanging_punctuation.pptx ». Avec Arial 24 pt et des marges horizontales du cadre de texte à zéro, le point final reste après « sentence » et dépasse le bord droit du texte. Définissez la propriété sur NullableBool.False_ pour comparer : avec ces réglages, le point occupe une ligne séparée. Le renvoi à la ligne est activé et l’ajustement automatique désactivé afin de garder la largeur disponible fixe.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FillType, FontData, NullableBool, Presentation, SaveFormat, ShapeType, TextAlignment, TextAutofitType
from java.awt import Color
presentation = Presentation()
try:
slide = presentation.getSlides().get_Item(0)
shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 50, 50, 100, 200)
shape.getFillFormat().setFillType(FillType.NoFill)
text_frame = shape.getTextFrame()
text_frame.getTextFrameFormat().setWrapText(NullableBool.True_)
text_frame.getTextFrameFormat().setAutofitType(TextAutofitType.None_)
text_frame.getTextFrameFormat().setMarginLeft(0)
text_frame.getTextFrameFormat().setMarginRight(0)
paragraph = text_frame.getParagraphs().get_Item(0)
paragraph.setText("Simple text, next sentence.")
paragraph_format = paragraph.getParagraphFormat()
paragraph_format.setAlignment(TextAlignment.Left)
paragraph_format.getDefaultPortionFormat().setFontHeight(24)
latin_font = FontData("Arial")
paragraph_format.getDefaultPortionFormat().setLatinFont(latin_font)
paragraph_format.getDefaultPortionFormat().getFillFormat().setFillType(FillType.Solid)
paragraph_format.getDefaultPortionFormat().getFillFormat().getSolidFillColor().setColor(Color.BLACK)
paragraph_format.setHangingPunctuation(NullableBool.True_)
presentation.save("hanging_punctuation.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Toutes les marques de ponctuation ne peuvent pas être suspendues. Les conditions de police et de mise en page décrites plus haut s’appliquent également à cette comparaison : modifier la police, la largeur disponible, les marges ou les paramètres d’ajustement peut éliminer la différence visible.
Définir le type d’ajustement automatique pour les cadres de texte
TextFrameFormat.setAutofitType 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 se redimensionne afin de s’adapter à son texte et enregistre le résultat sous « autofit_type.pptx ».
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat, TextAutofitType
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
auto_shape.getTextFrame().getTextFrameFormat().setAutofitType(TextAutofitType.Shape)
presentation.save("autofit_type.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Pour compter les lignes après le renvoi à la ligne automatique et voir comment la largeur du texte ou de la forme change le résultat, voir Count Rendered Lines. Le simple nombre de lignes n’indique pas si le texte déborde de son conteneur.
Définir l’ancre des cadres de texte
TextFrameFormat.setAnchoringType définit comment le texte est positionné verticalement à l’intérieur d’une forme, par exemple en haut, au centre 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 jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat, TextAnchorType
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
auto_shape.getTextFrame().getTextFrameFormat().setAnchoringType(TextAnchorType.Bottom)
presentation.save("text_anchor.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Définir la tabulation du texte
Utilisez ParagraphFormat.setDefaultTabSize et ParagraphFormat.getTabs pour configurer les taquets de tabulation dans un paragraphe. L’exemple suivant fixe l’intervalle de tabulation par défaut à 100 points et ajoute un taquet de tabulation aligné à gauche à 30 points. Ces réglages affectent le texte contenant des caractères de tabulation.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, SaveFormat, TabAlignment
presentation = Presentation("sample.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
paragraph.getParagraphFormat().setDefaultTabSize(100)
paragraph.getParagraphFormat().getTabs().add(30, TabAlignment.Left)
presentation.save("paragraph_tabs.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Le résultat :

Définir la langue de vérification
Aspose.Slides fournit BasePortionFormat.setLanguageId, 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 l’orthographe et la grammaire dans PowerPoint.
L’exemple suivant nécessite « presentation.pptx » avec une zone de texte comme première forme sur 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 Simplified Chinese (zh-CN). Il enregistre le résultat sous « proofing_language.pptx »:
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import FontData, Portion, Presentation, SaveFormat
presentation = Presentation("presentation.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
paragraph = auto_shape.getTextFrame().getParagraphs().get_Item(0)
paragraph.getPortions().clear()
font = FontData("SimSun")
text_portion = Portion()
text_portion.getPortionFormat().setComplexScriptFont(font)
text_portion.getPortionFormat().setEastAsianFont(font)
text_portion.getPortionFormat().setLatinFont(font)
# Définir l'Id d'une langue de vérification.
text_portion.getPortionFormat().setLanguageId("zh-CN")
text_portion.setText("1。")
paragraph.getPortions().add(text_portion)
presentation.save("proofing_language.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Définir la langue par défaut
Utilisez LoadOptions.setDefaultTextLanguage 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 jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import LoadOptions, Presentation, ShapeType
load_options = LoadOptions()
load_options.setDefaultTextLanguage("en-US")
presentation = Presentation(load_options)
try:
slide = presentation.getSlides().get_Item(0)
# Ajouter une forme rectangle avec du texte.
shape = slide.getShapes().addAutoShape(ShapeType.Rectangle, 20, 20, 150, 50)
shape.getTextFrame().setText("Sample text")
# Vérifier la langue de la première portion.
portion = shape.getTextFrame().getParagraphs().get_Item(0).getPortions().get_Item(0)
print(portion.getPortionFormat().getLanguageId())
finally:
presentation.dispose()
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.getDefaultTextStyle.
L’exemple suivant définit une police en gras de 14 pt 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 sauf si un formatage plus spécifique les remplace.
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import NullableBool, Presentation, SaveFormat
presentation = Presentation()
try:
# Obtenir le format de paragraphe de niveau supérieur.
paragraph_format = presentation.getDefaultTextStyle().getLevel(0)
if paragraph_format is not None:
paragraph_format.getDefaultPortionFormat().setFontHeight(14)
paragraph_format.getDefaultPortionFormat().setFontBold(NullableBool.True_)
presentation.save("default_text_style.pptx", SaveFormat.Pptx)
finally:
presentation.dispose()
Extraire le texte avec l’effet tout en 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 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é saisi. Pour faire correspondre le 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 sur la première diapositive. Sa première portion du premier paragraphe contient « Hello, Aspose! » avec l’effet All Caps appliqué, comme illustré ci‑dessous.

Le code suivant montre comment extraire le texte avec l’effet All Caps appliqué :
import jpype
import asposeslides
if not jpype.isJVMStarted():
jpype.startJVM()
from asposeslides.api import Presentation, TextCapType
presentation = Presentation("sample2.pptx")
try:
slide = presentation.getSlides().get_Item(0)
auto_shape = slide.getShapes().get_Item(0)
text_portion = auto_shape.getTextFrame().getParagraphs().get_Item(0).getPortions().get_Item(0)
print("Original text: " + str(text_portion.getText()))
text_format = text_portion.getPortionFormat().getEffective()
if text_format.getTextCapType() == TextCapType.All:
text = str(text_portion.getText()).upper()
print("All-Caps effect: " + text)
finally:
presentation.dispose()
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.getTextFrame et le formatage des paragraphes via Paragraph.getParagraphFormat.
Comment appliquer une couleur dégradée au texte d’une diapositive PowerPoint ?
Pour appliquer une couleur dégradée au texte, utilisez BasePortionFormat.getFillFormat. Définissez FillFormat.setFillType sur FillType.Gradient et configurez les arrêts du dégradé, la direction et la transparence.