Gerenciar Temas de Apresentação em JavaScript
Introdução
Um tema de apresentação define um conjunto coordenado de cores, fontes, estilos de plano de fundo, preenchimentos, linhas e efeitos. Objetos que reconhecem temas referem‑se a essas definições compartilhadas em vez de armazenar cada propriedade visual como um valor fixo, de modo que uma mudança de tema pode atualizar muitos objetos de uma vez.
No Aspose.Slides, o tema a nível de apresentação está disponível por meio de Presentation.getMasterTheme. Uma apresentação também pode conter substituições de tema em níveis mais baixos. Um mestre pode substituir o tema da apresentação através de MasterThemeManager.getOverrideTheme, enquanto um layout ou um slide individual pode substituir seu tema herdado através de BaseOverrideThemeManager.getOverrideTheme. Na prática, o tema efetivo de um slide é resolvido por esta cadeia de herança: tema da apresentação, substituição de mestre, substituição de layout e substituição de slide.
As seções abaixo mostram os fluxos de trabalho de tema mais comuns: inspecionar um tema, alterar cores e fontes, copiar ou aplicar um tema, atualizar estilos de plano de fundo e efeitos, e ler valores efetivos após a herança e as substituições serem resolvidas.
Inspecionar um Tema
O objeto MasterTheme expõe o esquema de cores, o esquema de fontes e o esquema de formatos do tema através de MasterTheme.getColorScheme, MasterTheme.getFontScheme e MasterTheme.getFormatScheme. Inspecionar essas coleções antes de alterá‑las é especialmente útil quando uma apresentação vem de uma fonte externa, pois o número e o conteúdo das entradas de estilo podem variar.
O exemplo a seguir lê as principais propriedades do tema e relata quantos estilos de plano de fundo, preenchimento, linha e efeito estão armazenados no tema:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const presentation = new aspose.slides.Presentation("input.pptx");
try {
const theme = presentation.getMasterTheme();
console.log("Theme name: " + theme.getName());
console.log("Accent 1: " + theme.getColorScheme().getAccent1().getColor());
console.log("Major Latin font: " + theme.getFontScheme().getMajor().getLatinFont().getFontName());
console.log("Minor Latin font: " + theme.getFontScheme().getMinor().getLatinFont().getFontName());
console.log("Background fill styles: " + theme.getFormatScheme().getBackgroundFillStyles().size());
console.log("Fill styles: " + theme.getFormatScheme().getFillStyles().size());
console.log("Line styles: " + theme.getFormatScheme().getLineStyles().size());
console.log("Effect styles: " + theme.getFormatScheme().getEffectStyles().size());
} finally {
presentation.dispose();
}
Se um arquivo usar vários mestres, não presuma que cada slide tenha o mesmo tema efetivo. Inspecione o mestre associado ao slide e use o fluxo de trabalho de tema efetivo mostrado mais adiante neste artigo quando substituições de layout ou slide puderem estar presentes.
Alterar Cores do Tema
Preenchimentos, linhas e texto que reconhecem temas podem referir‑se a uma cor lógica da enumeração SchemeColor. Quando você altera a entrada correspondente no ColorScheme, todos os objetos que ainda referenciam aquela cor do tema são resolvidos contra o novo valor. Objetos que utilizam uma cor RGB direta não são alterados por uma atualização de cor do tema.
O exemplo end‑to‑end a seguir cria uma forma que usa Accent4, altera a cor Accent4 do tema para vermelho, salva a apresentação, reabre‑a e imprime a cor de preenchimento efetiva:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const java = require("java");
const presentation = new aspose.slides.Presentation();
try {
const slide = presentation.getSlides().get_Item(0);
const shape = slide.getShapes().addAutoShape(aspose.slides.ShapeType.Rectangle, 10, 10, 100, 100);
shape.getFillFormat().setFillType(java.newByte(aspose.slides.FillType.Solid));
shape.getFillFormat().getSolidFillColor().setSchemeColor(aspose.slides.SchemeColor.Accent4);
presentation.getMasterTheme().getColorScheme().getAccent4().setColor(java.getStaticFieldValue("java.awt.Color", "RED"));
presentation.save("theme-color.pptx", aspose.slides.SaveFormat.Pptx);
} finally {
presentation.dispose();
}
const savedPresentation = new aspose.slides.Presentation("theme-color.pptx");
try {
const savedSlide = savedPresentation.getSlides().get_Item(0);
const savedShape = savedSlide.getShapes().get_Item(0);
const effectiveFill = savedShape.getFillFormat().getEffective();
console.log("Effective fill color: " + effectiveFill.getSolidFillColor());
} finally {
savedPresentation.dispose();
}
Como o retângulo permanece vinculado ao Accent4, sua cor visível torna‑se vermelha após a alteração do tema. Se você substituir a cor de esquema por uma cor direta na forma, alterações posteriores em Accent4 não afetarão mais esse preenchimento.
Usar Cores da Paleta Adicional
O PowerPoint gera variantes mais claras e mais escuras de uma cor do tema aplicando transformações de cor. O Aspose.Slides expõe essas transformações por meio da enumeração ColorTransformOperation.
1 – Cores principais do tema.
2 – Variantes mais claras e mais escuras produzidas a partir das cores principais do tema.
O exemplo a seguir cria seis retângulos baseados em Accent4, aplica transformações de luminância a cinco deles e salva o resultado:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const java = require("java");
const presentation = new aspose.slides.Presentation();
try {
const slide = presentation.getSlides().get_Item(0);
const shape1 = slide.getShapes().addAutoShape(aspose.slides.ShapeType.Rectangle, 10, 10, 50, 50);
shape1.getFillFormat().setFillType(java.newByte(aspose.slides.FillType.Solid));
shape1.getFillFormat().getSolidFillColor().setSchemeColor(aspose.slides.SchemeColor.Accent4);
const shape2 = slide.getShapes().addAutoShape(aspose.slides.ShapeType.Rectangle, 10, 70, 50, 50);
shape2.getFillFormat().setFillType(java.newByte(aspose.slides.FillType.Solid));
shape2.getFillFormat().getSolidFillColor().setSchemeColor(aspose.slides.SchemeColor.Accent4);
shape2.getFillFormat().getSolidFillColor().getColorTransform().add(aspose.slides.ColorTransformOperation.MultiplyLuminance, java.newFloat(0.2));
shape2.getFillFormat().getSolidFillColor().getColorTransform().add(aspose.slides.ColorTransformOperation.AddLuminance, java.newFloat(0.8));
const shape3 = slide.getShapes().addAutoShape(aspose.slides.ShapeType.Rectangle, 10, 130, 50, 50);
shape3.getFillFormat().setFillType(java.newByte(aspose.slides.FillType.Solid));
shape3.getFillFormat().getSolidFillColor().setSchemeColor(aspose.slides.SchemeColor.Accent4);
shape3.getFillFormat().getSolidFillColor().getColorTransform().add(aspose.slides.ColorTransformOperation.MultiplyLuminance, java.newFloat(0.4));
shape3.getFillFormat().getSolidFillColor().getColorTransform().add(aspose.slides.ColorTransformOperation.AddLuminance, java.newFloat(0.6));
const shape4 = slide.getShapes().addAutoShape(aspose.slides.ShapeType.Rectangle, 10, 190, 50, 50);
shape4.getFillFormat().setFillType(java.newByte(aspose.slides.FillType.Solid));
shape4.getFillFormat().getSolidFillColor().setSchemeColor(aspose.slides.SchemeColor.Accent4);
shape4.getFillFormat().getSolidFillColor().getColorTransform().add(aspose.slides.ColorTransformOperation.MultiplyLuminance, java.newFloat(0.6));
shape4.getFillFormat().getSolidFillColor().getColorTransform().add(aspose.slides.ColorTransformOperation.AddLuminance, java.newFloat(0.4));
const shape5 = slide.getShapes().addAutoShape(aspose.slides.ShapeType.Rectangle, 10, 250, 50, 50);
shape5.getFillFormat().setFillType(java.newByte(aspose.slides.FillType.Solid));
shape5.getFillFormat().getSolidFillColor().setSchemeColor(aspose.slides.SchemeColor.Accent4);
shape5.getFillFormat().getSolidFillColor().getColorTransform().add(aspose.slides.ColorTransformOperation.MultiplyLuminance, java.newFloat(0.75));
const shape6 = slide.getShapes().addAutoShape(aspose.slides.ShapeType.Rectangle, 10, 310, 50, 50);
shape6.getFillFormat().setFillType(java.newByte(aspose.slides.FillType.Solid));
shape6.getFillFormat().getSolidFillColor().setSchemeColor(aspose.slides.SchemeColor.Accent4);
shape6.getFillFormat().getSolidFillColor().getColorTransform().add(aspose.slides.ColorTransformOperation.MultiplyLuminance, java.newFloat(0.5));
presentation.save("theme-color-palette.pptx", aspose.slides.SaveFormat.Pptx);
} finally {
presentation.dispose();
}
Essas variantes permanecem baseadas na cor do tema. Se Accent4 mudar posteriormente, as cores transformadas são recalculadas a partir do novo valor de Accent4.
Mapear Valores de SchemeColor para Slots de ColorScheme
A enumeração SchemeColor usa Text1, Background1, Text2 e Background2, enquanto o ColorScheme expõe os mesmos slots de tema como Dark1, Light1, Dark2 e Light2. O mapeamento é fixo:
Text1=Dark1Background1=Light1Text2=Dark2Background2=Light2
Esses são nomes alternativos para os mesmos slots de tema; não são valores convertidos dinamicamente de uma forma para outra.
Alterar Fontes do Tema
Um esquema de fontes do tema contém um conjunto de fontes principais para títulos e um conjunto de fontes secundárias para o corpo do texto. Os métodos FontScheme.getMajor e FontScheme.getMinor expõem esses conjuntos.
Identificadores de fontes de tema compatíveis com PowerPoint podem ser usados na formatação de texto:
+mn-lt– Fonte do Corpo Latin (Fonte Secundária Latin)+mj-lt– Fonte do Título Latin (Fonte Principal Latin)+mn-ea– Fonte do Corpo East Asian (Fonte Secundária East Asian)+mj-ea– Fonte do Título East Asian (Fonte Principal East Asian)
O exemplo a seguir cria um título que usa a fonte temática principal Latin e uma linha de corpo que usa a fonte temática secundária Latin. Em seguida, altera as fontes do tema e salva o resultado:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const presentation = new aspose.slides.Presentation();
try {
const slide = presentation.getSlides().get_Item(0);
const heading = slide.getShapes().addAutoShape(aspose.slides.ShapeType.Rectangle, 40, 40, 500, 60);
heading.getTextFrame().setText("Theme heading");
heading.getTextFrame().getParagraphs().get_Item(0).getPortions().get_Item(0).getPortionFormat().setLatinFont(new aspose.slides.FontData("+mj-lt"));
const body = slide.getShapes().addAutoShape(aspose.slides.ShapeType.Rectangle, 40, 120, 500, 60);
body.getTextFrame().setText("Theme body text");
body.getTextFrame().getParagraphs().get_Item(0).getPortions().get_Item(0).getPortionFormat().setLatinFont(new aspose.slides.FontData("+mn-lt"));
presentation.getMasterTheme().getFontScheme().getMajor().setLatinFont(new aspose.slides.FontData("Aptos Display"));
presentation.getMasterTheme().getFontScheme().getMinor().setLatinFont(new aspose.slides.FontData("Arial"));
presentation.save("theme-fonts.pptx", aspose.slides.SaveFormat.Pptx);
} finally {
presentation.dispose();
}
O título segue a fonte principal e o texto do corpo segue a fonte secundária. Texto que possui um nome de fonte explícito em vez de um identificador de tema não mudará automaticamente quando o esquema de fontes do tema for alterado.
As coleções de fontes principal e secundária também podem conter mapeamentos de fontes para sistemas de escrita individuais, como Cirílico, Árabe, Japonês, Georgiano e Thaana. Para inspecionar, adicionar, substituir ou remover esses mapeamentos, veja Script-Specific Theme Fonts.
Tip
Para mais informações sobre fontes em apresentações, consulte PowerPoint Fonts.Copiar ou Aplicar um Tema
Os fluxos de trabalho abaixo resolvem diferentes problemas relacionados a temas.
Aplicar um Tema Externo aos Slides Dependentes de um Mestre
Use MasterSlide.applyExternalThemeToDependingSlides quando você possui um arquivo de tema do PowerPoint (.thmx) e deseja restilizar todos os slides que dependem de um mestre específico. Selecione o mestre da coleção Presentation.getMasters, que é representada por MasterSlideCollection, e passe o caminho do arquivo de tema para o método.
O método executa as seguintes operações:
- Cria um novo slide mestre baseado no mestre selecionado.
- Aplica o tema externo ao novo mestre.
- Atribui o novo mestre a todos os slides que anteriormente dependiam do mestre selecionado.
- Retorna o MasterSlide recém‑criado.
O exemplo a seguir aplica um tema externo aos slides que dependem do primeiro mestre e salva a apresentação:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const presentation = new aspose.slides.Presentation("presentation.pptx");
try {
const selectedMaster = presentation.getMasters().get_Item(0);
const themedMaster = selectedMaster.applyExternalThemeToDependingSlides("corporate-theme.thmx");
console.log("Created master: " + themedMaster.getName());
presentation.save("presentation-with-external-theme.pptx", aspose.slides.SaveFormat.Pptx);
} finally {
presentation.dispose();
}
Um tema inválido, corrompido ou não suportado pode gerar PptxReadException. Valide os caminhos fornecidos pelos usuários, trate falhas de acesso ao sistema de arquivos e salve a apresentação somente após o tema ter sido aplicado com sucesso.
Apenas os slides que dependiam do mestre selecionado são reatribuídos. Slides associados a outros mestres mantêm seus mestres e temas existentes. Cores, fontes, preenchimentos, linhas, planos de fundo e efeitos que reconhecem temas são resolvidos contra o tema externo. Cores, fontes, preenchimentos e outras formatações atribuídas diretamente podem permanecer inalterados. Substituições em nível de layout e de slide também podem prevalecer sobre valores herdados do novo mestre.
O tema pode referenciar fontes que não estão disponíveis no ambiente de tempo de execução. Para renderização e exportação consistentes, instale as fontes necessárias, forneça‑as através de fontes personalizadas, ou configure substituição de fontes.
Este é um fluxo de trabalho direto ao nível de mestre: o método aceita um caminho de arquivo .thmx e não requer a criação manual de substituições de tema em nível de slide ou de layout.
Aplicar Temas Externos Diferentes em uma Apresentação com Múltiplos Mestres
Quando o mestre relevante não é conhecido de antemão, obtenha‑o a partir de um slide representativo por meio de Slide.getLayoutSlide e LayoutSlide.getMasterSlide. Armazene as referências originais dos mestres antes de aplicar quaisquer temas, pois cada chamada cria outro mestre na apresentação.
O exemplo a seguir usa slides de duas seções para localizar seus mestres e aplica um tema externo diferente a cada grupo:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const presentation = new aspose.slides.Presentation("multi-master-presentation.pptx");
try {
if (presentation.getSlides().size() < 5) {
console.log("The presentation does not contain the expected representative slides.");
} else {
const firstGroupMaster = presentation.getSlides().get_Item(0).getLayoutSlide().getMasterSlide();
const secondGroupMaster = presentation.getSlides().get_Item(4).getLayoutSlide().getMasterSlide();
if (firstGroupMaster.getSlideId() === secondGroupMaster.getSlideId()) {
console.log("The representative slides use the same master.");
} else {
const firstThemedMaster = firstGroupMaster.applyExternalThemeToDependingSlides("blue-theme.thmx");
const secondThemedMaster = secondGroupMaster.applyExternalThemeToDependingSlides("green-theme.thmx");
console.log("First themed master: " + firstThemedMaster.getName());
console.log("Second themed master: " + secondThemedMaster.getName());
presentation.save("multi-master-with-external-themes.pptx", aspose.slides.SaveFormat.Pptx);
}
}
} finally {
presentation.dispose();
}
A primeira chamada afeta apenas os slides que dependiam de firstGroupMaster, e a segunda chamada afeta apenas os slides que dependiam de secondGroupMaster. Slides pertencentes a qualquer outro mestre não são restilizados.
Preservar o Tema de Origem ao Mover Slides
Se você deseja mover um slide para outra apresentação e preservar seu design original, clone o mestre de origem na apresentação de destino com MasterSlideCollection.addClone, depois clone o slide com SlideCollection.addClone e o mestre clonado. Isso transporta o mestre, seus layouts e o tema associado juntos.
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const source = new aspose.slides.Presentation("source-theme.pptx");
try {
const target = new aspose.slides.Presentation("target.pptx");
try {
const sourceSlide = source.getSlides().get_Item(0);
const clonedMaster = target.getMasters().addClone(sourceSlide.getLayoutSlide().getMasterSlide());
target.getSlides().addClone(sourceSlide, clonedMaster, true);
target.save("theme-preserved.pptx", aspose.slides.SaveFormat.Pptx);
} finally {
target.dispose();
}
} finally {
source.dispose();
}
Este é o fluxo de trabalho preferido quando o slide de origem deve permanecer igual no destino. simplesmente clonar o conteúdo sobre um mestre de destino não relacionado pode mudar cores, fontes, planos de fundo e efeitos controlados por tema.
Aplicar Valores de Tema a um Slide Existente
Se o slide de destino deve permanecer no mestre e layout atuais, inicialize uma substituição em nível de slide a partir do tema de origem. Os métodos OverrideTheme.initColorSchemeFrom, OverrideTheme.initFontSchemeFrom e OverrideTheme.initFormatSchemeFrom copiam os três principais componentes do tema para a substituição.
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const source = new aspose.slides.Presentation("source-theme.pptx");
try {
const target = new aspose.slides.Presentation("target.pptx");
try {
const sourceTheme = source.getMasterTheme();
const targetSlide = target.getSlides().get_Item(0);
const overrideTheme = targetSlide.getThemeManager().getOverrideTheme();
overrideTheme.initColorSchemeFrom(sourceTheme.getColorScheme());
overrideTheme.initFontSchemeFrom(sourceTheme.getFontScheme());
overrideTheme.initFormatSchemeFrom(sourceTheme.getFormatScheme());
target.save("theme-applied-to-slide.pptx", aspose.slides.SaveFormat.Pptx);
} finally {
target.dispose();
}
} finally {
source.dispose();
}
Isso altera o tema usado por esse slide sem mudar o tema herdado por outros slides. Para remover a substituição local e retornar aos valores herdados, chame OverrideTheme.clear.
Aplicar uma Substituição de Tema a um Layout
Uma substituição em nível de layout aplica‑se aos slides que usam esse layout, a menos que um slide específico possua sua própria substituição. Os mesmos métodos de inicialização podem ser usados através de LayoutSlideThemeManager:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const source = new aspose.slides.Presentation("source-theme.pptx");
try {
const target = new aspose.slides.Presentation("target.pptx");
try {
const sourceTheme = source.getMasterTheme();
const targetSlide = target.getSlides().get_Item(0);
const overrideTheme = targetSlide.getLayoutSlide().getThemeManager().getOverrideTheme();
overrideTheme.initColorSchemeFrom(sourceTheme.getColorScheme());
overrideTheme.initFontSchemeFrom(sourceTheme.getFontScheme());
overrideTheme.initFormatSchemeFrom(sourceTheme.getFormatScheme());
target.save("theme-applied-to-layout.pptx", aspose.slides.SaveFormat.Pptx);
} finally {
target.dispose();
}
} finally {
source.dispose();
}
Use um tema ao nível de mestre ou apresentação quando muitos layouts e slides devem compartilhar o mesmo design base, uma substituição de layout quando uma família de layouts precisa de estilo diferente, e uma substituição de slide apenas para exceções reais. Substituições excessivas em nível de slide dificultam a predição de mudanças globais de tema posteriores.
Atualizar Estilos de Plano de Fundo do Tema
Os preenchimentos de plano de fundo do tema são armazenados em FormatScheme.getBackgroundFillStyles. O PowerPoint pode apresentar mais opções de plano de fundo em sua UI do que o número de definições de preenchimento armazenadas fisicamente nesta coleção, pois a UI pode combinar preenchimentos de tema com cores de tema e outras referências de estilo.
Antes de usar um estilo de plano de fundo, inspecione a coleção armazenada e o índice de estilo atual de Background.getStyleIndex. Um índice de estilo 0 significa que não há preenchimento temático; valores positivos são referências a estilos de plano de fundo temáticos. Isso difere da indexação direta da coleção JavaScript, onde 0 indica o primeiro item armazenado. Não presuma que toda apresentação contenha o mesmo número de estilos de preenchimento de plano de fundo.
O exemplo a seguir relata a quantidade de preenchimentos de plano de fundo disponíveis, atribui uma referência de plano de fundo temático ao primeiro mestre e salva a apresentação:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const java = require("java");
const presentation = new aspose.slides.Presentation("input.pptx");
try {
const backgroundStyles = presentation.getMasterTheme().getFormatScheme().getBackgroundFillStyles();
console.log("Background fill styles: " + backgroundStyles.size());
if (backgroundStyles.size() === 0) {
throw new Error("The presentation theme does not contain background fill styles.");
}
const masterSlide = presentation.getMasters().get_Item(0);
masterSlide.getBackground().setType(java.newByte(aspose.slides.BackgroundType.Themed));
masterSlide.getBackground().setStyleIndex(1);
presentation.save("theme-background.pptx", aspose.slides.SaveFormat.Pptx);
} finally {
presentation.dispose();
}
O resultado visível depende da entrada de tema referenciada pelo mestre e de quaisquer substituições de plano de fundo no nível de layout ou slide. Se um slide usa seu próprio plano de fundo, mudar apenas o plano de fundo do mestre pode não alterar esse slide. Use Background.getEffective quando precisar conhecer o plano de fundo final após a aplicação da herança.
Warning
Não trate o índice de estilo como um índice de coleção zero‑based. Também evite codificar um número de estilo de um arquivo e presumir que ele terá a mesma aparência em outro arquivo; definições de estilo de tema são específicas da apresentação.Tip
Para formatação direta de plano de fundo e herança de plano de fundo, veja Presentation Background.Atualizar Efeitos do Tema
Um esquema de formato de tema contém coleções separadas de preenchimento, linha e estilo de efeito expostas por meio de FormatScheme.getFillStyles, FormatScheme.getLineStyles e FormatScheme.getEffectStyles. Temas típicos do Office costumam conter três entradas de estilo principais que correspondem visualmente a formatação sutil, moderada e intensa, mas o código deve inspecionar cada coleção ao invés de assumir uma contagem fixa.
Ao acessar essas coleções em JavaScript, o índice da coleção é zero‑based: índice 0 é o primeiro estilo armazenado e índice 2 é o terceiro. Os índices de referência de estilo de uma forma são um conceito separado, exposto por ShapeStyle. Modificar um estilo de tema afeta formas que referenciam esse estilo; formas com formatação direta podem permanecer inalteradas.
O exemplo a seguir verifica se as entradas de estilo necessárias existem, altera o primeiro estilo de linha, altera o terceiro estilo de preenchimento, habilita uma sombra externa no terceiro estilo de efeito e salva o resultado:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const java = require("java");
const presentation = new aspose.slides.Presentation("Subtle_Moderate_Intense.pptx");
try {
const formatScheme = presentation.getMasterTheme().getFormatScheme();
if (formatScheme.getLineStyles().size() < 1 || formatScheme.getFillStyles().size() < 3 || formatScheme.getEffectStyles().size() < 3) {
throw new Error("The theme does not contain the style entries required by this example.");
}
formatScheme.getLineStyles().get_Item(0).getFillFormat().setFillType(java.newByte(aspose.slides.FillType.Solid));
formatScheme.getLineStyles().get_Item(0).getFillFormat().getSolidFillColor().setColor(java.getStaticFieldValue("java.awt.Color", "RED"));
formatScheme.getFillStyles().get_Item(2).setFillType(java.newByte(aspose.slides.FillType.Solid));
formatScheme.getFillStyles().get_Item(2).getSolidFillColor().setColor(java.newInstanceSync("java.awt.Color", 34, 139, 34));
const effectFormat = formatScheme.getEffectStyles().get_Item(2).getEffectFormat();
effectFormat.enableOuterShadowEffect();
effectFormat.getOuterShadowEffect().setDistance(10);
presentation.save("theme-effects.pptx", aspose.slides.SaveFormat.Pptx);
} finally {
presentation.dispose();
}
Para formas que referenciam esses slots, o primeiro estilo de linha do tema torna‑se vermelho, o terceiro estilo de preenchimento do tema torna‑se verde floresta sólido, e o terceiro estilo de efeito ganha uma sombra externa com distância de 10 pontos. O resultado visual exato ainda depende de quais slots de estilo cada forma referencia e se a formatação direta substitui o tema.
Determinar se um Preenchimento Sólido Efetivo Usa uma Cor de Tema
Um preenchimento pode ser armazenado diretamente em um objeto ou herdado de um parágrafo, layout, mestre, estilo de tema ou outro nível de formatação. Chame FillFormat.getEffective para resolver essa hierarquia em uma captura de preenchimento efetivo imutável. Primeiro verifique o valor de getFillType. Somente quando for FillType.Solid você deve ler as propriedades de preenchimento sólido.
Para um preenchimento sólido, getSolidFillColor devolve o valor RGB final renderizado após a herança, pesquisa de tema e aplicação de transformações de cor. O método getSolidFillSchemeColor devolve o slot lógico correspondente de SchemeColor, como Text1 ou Accent6. Um valor SchemeColor.NotDefined indica que o preenchimento sólido efetivo não se baseia em uma cor de esquema. Em um fluxo onde preenchimentos são cores de tema ou cores RGB diretas, esse valor identifica um preenchimento RGB direto.
Não utilize apenas o valor local de ColorFormat.getSchemeColor para classificar um preenchimento. Por exemplo, uma porção de texto pode não ter cor de esquema definida localmente, portanto seu valor local é NotDefined, enquanto seu preenchimento efetivo herda uma cor de tema e resolve para Text1 ou Accent6. Por outro lado, getSolidFillSchemeColor informa qual slot lógico de tema produziu a cor efetiva, mas não indica se esse slot veio do objeto, parágrafo, layout, mestre ou outro nível da hierarquia.
O exemplo a seguir carrega uma apresentação, audita preenchimentos de formas e de porções de texto, imprime cada valor RGB final e a cor de esquema associada, e sinaliza preenchimentos sólidos que não acompanharão mudanças de cor de tema:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const java = require("java");
function toHexColor(color) {
const red = color.getRed().toString(16).padStart(2, "0");
const green = color.getGreen().toString(16).padStart(2, "0");
const blue = color.getBlue().toString(16).padStart(2, "0");
return `#${red}${green}${blue}`.toUpperCase();
}
function auditFill(objectName, localFill) {
const effectiveFill = localFill.getEffective();
if (effectiveFill.getFillType() !== aspose.slides.FillType.Solid) {
console.log(objectName + ": fill type = " + effectiveFill.getFillType() + "; not a solid fill.");
return;
}
const rgb = effectiveFill.getSolidFillColor();
const effectiveSchemeColor = effectiveFill.getSolidFillSchemeColor();
const localSchemeColor = localFill.getSolidFillColor().getSchemeColor();
console.log(objectName + ": RGB = " + toHexColor(rgb));
console.log(objectName + ": local scheme = " + localSchemeColor + ", effective scheme = " + effectiveSchemeColor);
if (effectiveSchemeColor === aspose.slides.SchemeColor.NotDefined) {
console.log(objectName + ": direct RGB or another non-scheme fill; audit as theme-independent.");
} else {
console.log(objectName + ": theme-dependent through " + effectiveSchemeColor + ".");
}
}
const presentation = new aspose.slides.Presentation("input.pptx");
try {
const slideCount = presentation.getSlides().size();
for (let slideIndex = 0; slideIndex < slideCount; slideIndex++) {
const slide = presentation.getSlides().get_Item(slideIndex);
const shapeCount = slide.getShapes().size();
for (let shapeIndex = 0; shapeIndex < shapeCount; shapeIndex++) {
const shape = slide.getShapes().get_Item(shapeIndex);
const shapeName = "Slide " + (slideIndex + 1) + ", shape " + (shapeIndex + 1);
auditFill(shapeName, shape.getFillFormat());
if (java.instanceOf(shape, "com.aspose.slides.IAutoShape")) {
const paragraphCount = shape.getTextFrame().getParagraphs().getCount();
for (let paragraphIndex = 0; paragraphIndex < paragraphCount; paragraphIndex++) {
const paragraph = shape.getTextFrame().getParagraphs().get_Item(paragraphIndex);
const portionCount = paragraph.getPortions().getCount();
for (let portionIndex = 0; portionIndex < portionCount; portionIndex++) {
const portion = paragraph.getPortions().get_Item(portionIndex);
const portionName = shapeName + ", paragraph " + (paragraphIndex + 1) + ", portion " + (portionIndex + 1);
auditFill(portionName, portion.getPortionFormat().getFillFormat());
}
}
}
}
}
} finally {
presentation.dispose();
}
O ramo NotDefined fornece uma lista de auditoria de preenchimentos sólidos que não responderão a alterações nos slots de cor de tema. Revise esses objetos quando uma apresentação precisar seguir uma nova paleta de marca. O valor RGB reportado ainda mostra a aparência atual, enquanto o valor de esquema explica se essa aparência está conectado ao tema.
Objetos de formato efetivo são capturas. Após mudar o tema da apresentação, uma substituição de tema ou qualquer formatação herdada, chame getEffective novamente e leia um novo objeto de preenchimento efetivo antes de comparar ou relatar cores.
Ler Valores de Tema Efetivos
Objetos de tema brutos informam o que está definido em um determinado nível. Valores efetivos informam o que um slide ou forma realmente usa após a herança e as substituições locais serem resolvidas. Para um slide, chame BaseOverrideThemeManager.createThemeEffective. Para um plano de fundo, use Background.getEffective, e para um preenchimento, use FillFormat.getEffective.
O exemplo a seguir lê o tema efetivo, o plano de fundo e o primeiro preenchimento de forma de um slide:
const aspose = {};
aspose.slides = require("aspose.slides.via.java");
const presentation = new aspose.slides.Presentation("input.pptx");
try {
const slide = presentation.getSlides().get_Item(0);
const effectiveTheme = slide.getThemeManager().createThemeEffective();
const effectiveBackground = slide.getBackground().getEffective();
console.log("Effective major Latin font: " + effectiveTheme.getFontScheme().getMajor().getLatinFont().getFontName());
console.log("Effective minor Latin font: " + effectiveTheme.getFontScheme().getMinor().getLatinFont().getFontName());
console.log("Effective background fill type: " + effectiveBackground.getFillFormat().getFillType());
if (slide.getShapes().size() > 0) {
const effectiveFill = slide.getShapes().get_Item(0).getFillFormat().getEffective();
console.log("First shape effective fill type: " + effectiveFill.getFillType());
if (effectiveFill.getFillType() === aspose.slides.FillType.Solid) {
console.log("First shape effective fill color: " + effectiveFill.getSolidFillColor());
}
}
} finally {
presentation.dispose();
}
Use dados efetivos para diagnósticos de renderização, validação e comparações. Se você inspecionar apenas Presentation.getMasterTheme, pode perder uma substituição de mestre, layout, slide ou forma que altere a aparência final.
FAQ
Aplicar um tema externo afeta todos os slides da apresentação?
Não. MasterSlide.applyExternalThemeToDependingSlides reatribui apenas os slides que dependem do mestre selecionado. Slides que usam outros mestres mantêm seus temas existentes.
Posso aplicar um tema a um único slide sem mudar o mestre?
Sim. Use o SlideThemeManager do slide e inicialize sua substituição de tema. A alteração permanece local a esse slide; os demais slides continuam herdando seus temas atuais.
Qual é a maneira mais segura de transportar um tema de uma apresentação para outra?
Ao mover um slide e preservar sua aparência original, clone o mestre de origem na apresentação de destino e clone o slide com esse mestre usando MasterSlideCollection.addClone e SlideCollection.addClone. Isso mantém o mestre, os layouts e o tema juntos.
Como posso ver os valores efetivos após herança e substituições?
Use BaseOverrideThemeManager.createThemeEffective para um slide ou tema de layout e os métodos de dados efetivos correspondentes para objetos de formato, como Background.getEffective e FillFormat.getEffective. Essas APIs retornam os valores resolvidos após a aplicação de herança e substituições.