Gerenciar Transições de Slide em Apresentações Usando C++
Visão geral
As transições de slide controlam como os slides aparecem durante uma apresentação. Com Aspose.Slides for C++, você pode escolher um efeito de transição para cada slide, configurar o avanço por clique do mouse ou temporizador e ajustar opções específicas de um efeito. Este artigo usa exemplos em C++ para aplicar transições, definir durações exatas de transição, gerenciar o tempo dos slides e criar uma transição Morph entre dois slides. Os exemplos também mostram como salvar as configurações em um arquivo PPTX.
Adicionar Transição de Slide
Para aplicar uma transição, carregue uma apresentação com a classe Presentation e acesse as configurações de transição de um slide através de get_SlideShowTransition. Chame set_Type com um valor da enumeração TransitionType, então salve a apresentação.
O exemplo a seguir aplica uma transição Circle ao primeiro slide e uma transição Comb ao segundo. Use um arquivo input.pptx com pelo menos dois slides.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideShowTransition.h>
#include <DOM/SlideShowTransition/TransitionType.h>
#include <Export/SaveFormat.h>
#include <system/console.h>
using namespace System;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace Aspose::Slides::SlideShow;
auto presentation = MakeObject<Presentation>(u"input.pptx");
if (presentation->get_Slides()->get_Count() >= 2)
{
presentation->get_Slide(0)->get_SlideShowTransition()->set_Type(TransitionType::Circle);
presentation->get_Slide(1)->get_SlideShowTransition()->set_Type(TransitionType::Comb);
presentation->Save(u"slide-transitions.pptx", SaveFormat::Pptx);
}
else
{
Console::WriteLine(u"The input presentation must contain at least two slides.");
}
presentation->Dispose();
Transição Wheel
O método set_Spokes de IWheelTransition controla o número de setores radiais que revelam o slide de destino. Chame set_Type com Wheel da TransitionType antes de acessar get_Value como IWheelTransition.
Este exemplo cria dois pares idênticos de slides: um slide preto seguido por um slide com um retângulo dourado. Os slides de destino usam contagens de spokes de 1 e 8, com a mesma velocidade definida por set_Speed e uma duração explícita de 8.000 milissegundos definida por set_Duration para tornar a diferença fácil de observar.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideSize.h>
#include <DOM/ISlideShowTransition.h>
#include <DOM/IBackground.h>
#include <DOM/BackgroundType.h>
#include <DOM/IFillFormat.h>
#include <DOM/FillType.h>
#include <DOM/IColorFormat.h>
#include <DOM/IAutoShape.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ITextFrame.h>
#include <DOM/ShapeType.h>
#include <DOM/SlideShowTransition/IWheelTransition.h>
#include <DOM/SlideShowTransition/ITransitionValueBase.h>
#include <DOM/SlideShowTransition/TransitionType.h>
#include <DOM/SlideShowTransition/TransitionSpeed.h>
#include <Export/SaveFormat.h>
#include <drawing/color.h>
#include <drawing/size_f.h>
#include <system/object_ext.h>
#include <cstdint>
using namespace System;
using namespace System::Drawing;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace Aspose::Slides::SlideShow;
auto presentation = MakeObject<Presentation>();
auto slideWidth = presentation->get_SlideSize()->get_Size().get_Width();
auto slideHeight = presentation->get_SlideSize()->get_Size().get_Height();
auto blackSlide = presentation->get_Slide(0);
blackSlide->get_Shapes()->Clear();
blackSlide->get_Background()->set_Type(BackgroundType::OwnBackground);
blackSlide->get_Background()->get_FillFormat()->set_FillType(FillType::Solid);
blackSlide->get_Background()->get_FillFormat()->get_SolidFillColor()->set_Color(Color::get_Black());
auto destinationSlide = presentation->get_Slides()->AddClone(blackSlide);
auto rectangle = destinationSlide->get_Shapes()->AddAutoShape(ShapeType::Rectangle, 0, 0, slideWidth, slideHeight);
rectangle->get_FillFormat()->set_FillType(FillType::Solid);
rectangle->get_FillFormat()->get_SolidFillColor()->set_Color(Color::get_Gold());
rectangle->get_TextFrame()->set_Text(u"Wheel transition");
presentation->get_Slides()->AddClone(blackSlide);
presentation->get_Slides()->AddClone(destinationSlide);
const uint32_t spokeCounts[] = { 1, 8 };
for (auto i = 0; i < 2; i++)
{
auto transition = presentation->get_Slide(i * 2 + 1)->get_SlideShowTransition();
transition->set_Type(TransitionType::Wheel);
auto wheelTransition = ExplicitCast<IWheelTransition>(transition->get_Value());
wheelTransition->set_Spokes(spokeCounts[i]);
transition->set_Speed(TransitionSpeed::Slow);
transition->set_Duration(8000);
}
presentation->Save(u"wheel-transitions.pptx", SaveFormat::Pptx);
presentation->Dispose();
Abra a apresentação de saída no PowerPoint e execute a apresentação de slides. Avance do slide 1 para o slide 2, depois do slide 3 para o slide 4. Na reprodução do PowerPoint, a contagem de spokes verificada de 1 revela o slide com uma varredura horária única; a contagem verificada de 8 o revela através de oito setores radiais simultaneamente. O conteúdo de destino e o tempo da transição são idênticos, portanto a diferença está no número de setores de revelação.
Adicionar Transição de Slide Avançada
Você pode configurar quanto tempo um slide permanece na tela e se um clique do mouse avança a apresentação. Os métodos a seguir controlam esse comportamento:
- set_AdvanceOnClick permite que o visualizador avance clicando o mouse.
- set_AdvanceAfter habilita o avanço automático.
- set_AdvanceAfterTime especifica o atraso antes do avanço automático, em milissegundos.
Habilite tanto o avanço por clique quanto o cronometrado para que o visualizador avance com um clique ou espere pelo temporizador. Para usar apenas o temporizador, chame set_AdvanceOnClick com false. O atraso controla quando a apresentação avança; ele não define a duração do efeito visual de transição.
Este exemplo atribui efeitos diferentes aos três primeiros slides e habilita o avanço automático após 3, 5 e 7 segundos, respectivamente. Cliques do mouse também podem avançar esses slides. Use um arquivo input.pptx com pelo menos três slides.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideShowTransition.h>
#include <DOM/SlideShowTransition/TransitionType.h>
#include <Export/SaveFormat.h>
#include <system/console.h>
using namespace System;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace Aspose::Slides::SlideShow;
auto presentation = MakeObject<Presentation>(u"input.pptx");
if (presentation->get_Slides()->get_Count() >= 3)
{
auto firstTransition = presentation->get_Slide(0)->get_SlideShowTransition();
firstTransition->set_Type(TransitionType::Circle);
firstTransition->set_AdvanceOnClick(true);
firstTransition->set_AdvanceAfter(true);
firstTransition->set_AdvanceAfterTime(3000);
auto secondTransition = presentation->get_Slide(1)->get_SlideShowTransition();
secondTransition->set_Type(TransitionType::Comb);
secondTransition->set_AdvanceOnClick(true);
secondTransition->set_AdvanceAfter(true);
secondTransition->set_AdvanceAfterTime(5000);
auto thirdTransition = presentation->get_Slide(2)->get_SlideShowTransition();
thirdTransition->set_Type(TransitionType::Zoom);
thirdTransition->set_AdvanceOnClick(true);
thirdTransition->set_AdvanceAfter(true);
thirdTransition->set_AdvanceAfterTime(7000);
presentation->Save(u"advanced-transitions.pptx", SaveFormat::Pptx);
}
else
{
Console::WriteLine(u"The input presentation must contain at least three slides.");
}
presentation->Dispose();
Para verificar se o avanço cronometrado está habilitado, chame get_AdvanceAfter. Um atraso armazenado sozinho não indica que o temporizador está ativo.
O exemplo a seguir abre o arquivo salvo acima, relata cada temporizador habilitado e desabilita o avanço automático para slides com atraso maior que dois segundos. Ele habilita cliques do mouse para esses slides e salva as configurações atualizadas.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideShowTransition.h>
#include <Export/SaveFormat.h>
#include <system/console.h>
using namespace System;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
auto presentation = MakeObject<Presentation>(u"advanced-transitions.pptx");
for (auto&& slide : presentation->get_Slides())
{
auto transition = slide->get_SlideShowTransition();
if (transition->get_AdvanceAfter())
{
Console::WriteLine(u"Slide {0}: advance after {1} ms.", slide->get_SlideNumber(), transition->get_AdvanceAfterTime());
if (transition->get_AdvanceAfterTime() > 2000)
{
transition->set_AdvanceAfter(false);
transition->set_AdvanceOnClick(true);
}
}
}
presentation->Save(u"adjusted-transitions.pptx", SaveFormat::Pptx);
presentation->Dispose();
Controlar o Tempo da Transição com Precisão
Use set_Duration para especificar o comprimento exato de um efeito de transição em milissegundos. O método get_SlideShowTransition do slide expõe essas configurações através de ISlideShowTransition:
| Método | Propósito |
|---|---|
| set_Duration | Define a duração do próprio efeito de transição, em milissegundos. |
| set_AdvanceAfterTime | Define o atraso antes que o slide avance automaticamente, em milissegundos. Chame set_AdvanceAfter com true para ativar esse temporizador. |
| set_Speed | Seleciona uma categoria de velocidade predefinida da TransitionSpeed: Slow, Medium ou Fast. É usada quando nenhuma duração exata é especificada. |
set_Duration controla apenas o efeito de transição; ele não determina quanto tempo o slide permanece visível. Configure o atraso de avanço automático separadamente. Quando nenhuma duração explícita é definida, Aspose.Slides determina a duração do efeito a partir do tipo de transição e do valor retornado por get_Speed.
The shared example gives each slide a 750-ms Fade transition and separately enables automatic advancement at 5,000 ms. Transition duration controls the effect; advancement controls when to leave the slide. These bars are schematic settings, not a measured combined timeline.
Aplicar a Mesma Duração a Cada Slide
Para um ritmo consistente, aplique o mesmo efeito e a mesma duração exata a todos os slides. Este exemplo carrega input.pptx, seleciona Fade da TransitionType, e atribui a cada transição uma duração de 750 milissegundos. Ele habilita separadamente o avanço automático após 5.000 milissegundos e desabilita o avanço por clique do mouse, então salva o resultado como PPTX.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideShowTransition.h>
#include <DOM/SlideShowTransition/TransitionType.h>
#include <Export/SaveFormat.h>
using namespace System;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace Aspose::Slides::SlideShow;
auto presentation = MakeObject<Presentation>(u"input.pptx");
for (auto&& slide : presentation->get_Slides())
{
auto transition = slide->get_SlideShowTransition();
transition->set_Type(TransitionType::Fade);
transition->set_Duration(750);
// Configurar avanço automático independentemente da duração do efeito.
transition->set_AdvanceAfter(true);
transition->set_AdvanceAfterTime(5000);
transition->set_AdvanceOnClick(false);
}
presentation->Save(u"precise-transitions.pptx", SaveFormat::Pptx);
presentation->Dispose();
Definir Durações Diferentes para Slides Individuais
Slides diferentes podem usar durações de efeito distintas. Por exemplo, use uma transição breve para um slide de título e uma transição mais longa para a introdução de seção. Este exemplo define 500 milissegundos para o primeiro slide e 1.200 milissegundos para o segundo. Use um arquivo input.pptx com pelo menos dois slides.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideShowTransition.h>
#include <DOM/SlideShowTransition/TransitionType.h>
#include <Export/SaveFormat.h>
#include <system/console.h>
using namespace System;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace Aspose::Slides::SlideShow;
auto presentation = MakeObject<Presentation>(u"input.pptx");
if (presentation->get_Slides()->get_Count() >= 2)
{
auto firstTransition = presentation->get_Slide(0)->get_SlideShowTransition();
firstTransition->set_Type(TransitionType::Fade);
firstTransition->set_Duration(500);
auto secondTransition = presentation->get_Slide(1)->get_SlideShowTransition();
secondTransition->set_Type(TransitionType::Push);
secondTransition->set_Duration(1200);
presentation->Save(u"individual-transition-durations.pptx", SaveFormat::Pptx);
}
else
{
Console::WriteLine(u"The input presentation must contain at least two slides.");
}
presentation->Dispose();
Coordenar Transições com Saída Animada
Ao preparar um animated GIF, HTML5 presentation ou video, defina durações exatas de transição antes da exportação para corresponder ao ritmo desejado. Por exemplo, use um fade de 600 milissegundos entre cenas e ajuste separadamente o atraso de avanço de cada slide para permitir tempo para sua narração ou conteúdo.
Para GIF e vídeo, coordene a taxa de quadros da saída com a duração do efeito: 600 milissegundos correspondem a 18 quadros a 30 quadros por segundo. No HTML5, habilite transições animadas nas configurações de exportação. Verifique os efeitos e opções de tempo suportados pelo formato de exportação escolhido e visualize a saída para confirmar a sincronização.
Ler uma Duração de Transição Existente
Chame get_Duration antes de modificar a transição para determinar se um valor explícito está armazenado. Um valor de -1 significa que nenhuma duração explícita foi definida; um valor não negativo especifica a duração armazenada em milissegundos. O valor não definido não é a duração de reprodução calculada: Aspose.Slides usa o tipo de transição e o valor retornado por get_Speed para determinar essa duração. Definir um tipo de transição pode inicializar uma duração, portanto inspecione as configurações originais primeiro.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideShowTransition.h>
#include <DOM/SlideShowTransition/TransitionType.h>
#include <DOM/SlideShowTransition/TransitionSpeed.h>
#include <system/console.h>
using namespace System;
using namespace Aspose::Slides;
auto presentation = MakeObject<Presentation>(u"input.pptx");
for (auto&& slide : presentation->get_Slides())
{
auto transition = slide->get_SlideShowTransition();
auto duration = transition->get_Duration();
if (duration >= 0)
{
Console::WriteLine(u"Slide {0}: stored transition duration is {1} ms.", slide->get_SlideNumber(), duration);
}
else
{
Console::WriteLine(u"Slide {0}: no explicit duration; timing depends on {1} and {2}.", slide->get_SlideNumber(), transition->get_Type(), transition->get_Speed());
}
}
presentation->Dispose();
Transição Morph
A transição Morph anima alterações entre objetos em slides consecutivos. Para criar um efeito Morph simples, clone um slide, mova ou redimensione um objeto no clone e aplique a transição Morph ao segundo slide. Isso fornece aos objetos correspondentes a animação entre seus estados original e modificado.
O exemplo a seguir cria um slide com um retângulo de texto, clona o slide e altera a posição e o tamanho do retângulo no clone. Em seguida, seleciona Morph da enumeração TransitionType para o segundo slide. Abra o arquivo salvo em um visualizador de apresentações que suporte Morph para ver o efeito durante a apresentação de slides.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideShowTransition.h>
#include <DOM/IAutoShape.h>
#include <DOM/IShape.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ITextFrame.h>
#include <DOM/ShapeType.h>
#include <DOM/SlideShowTransition/TransitionType.h>
#include <Export/SaveFormat.h>
using namespace System;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace Aspose::Slides::SlideShow;
auto presentation = MakeObject<Presentation>();
auto firstSlide = presentation->get_Slide(0);
auto rectangle = firstSlide->get_Shapes()->AddAutoShape(ShapeType::Rectangle, 100, 100, 400, 100);
rectangle->get_TextFrame()->set_Text(u"Morph transition");
auto secondSlide = presentation->get_Slides()->AddClone(firstSlide);
auto movedRectangle = secondSlide->get_Shape(0);
movedRectangle->set_X(movedRectangle->get_X() + 100);
movedRectangle->set_Y(movedRectangle->get_Y() + 50);
movedRectangle->set_Width(movedRectangle->get_Width() - 200);
movedRectangle->set_Height(movedRectangle->get_Height() - 10);
secondSlide->get_SlideShowTransition()->set_Type(TransitionType::Morph);
presentation->Save(u"morph-transition.pptx", SaveFormat::Pptx);
presentation->Dispose();
Tipos de Transição Morph
A enumeração TransitionMorphType controla como o Morph corresponde e anima o conteúdo:
- ByObject trata cada forma como um objeto inteiro.
- ByWord anima texto correspondendo palavras, quando possível.
- ByChar anima texto correspondendo caracteres, quando possível.
Chame set_Type com Morph antes de acessar get_Value. O valor então fornece a interface IMorphTransition, cujo método set_MorphType seleciona o modo de correspondência.
Este exemplo abre a apresentação criada na seção anterior e configura o segundo slide para usar animação Morph baseada em palavras.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideShowTransition.h>
#include <DOM/SlideShowTransition/IMorphTransition.h>
#include <DOM/SlideShowTransition/ITransitionValueBase.h>
#include <DOM/SlideShowTransition/TransitionMorphType.h>
#include <DOM/SlideShowTransition/TransitionType.h>
#include <Export/SaveFormat.h>
#include <system/console.h>
#include <system/object_ext.h>
using namespace System;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace Aspose::Slides::SlideShow;
auto presentation = MakeObject<Presentation>(u"morph-transition.pptx");
if (presentation->get_Slides()->get_Count() >= 2)
{
auto transition = presentation->get_Slide(1)->get_SlideShowTransition();
transition->set_Type(TransitionType::Morph);
auto morphTransition = AsCast<IMorphTransition>(transition->get_Value());
if (morphTransition != nullptr)
{
morphTransition->set_MorphType(TransitionMorphType::ByWord);
presentation->Save(u"morph-by-word.pptx", SaveFormat::Pptx);
}
else
{
Console::WriteLine(u"Morph transition options are unavailable.");
}
}
else
{
Console::WriteLine(u"The input presentation must contain at least two slides.");
}
presentation->Dispose();
Definir Efeitos de Transição
Algumas transições expõem opções adicionais, como direção ou se o efeito começa a partir de uma tela preta. As opções disponíveis dependem do tipo de transição selecionado. Defina o tipo primeiro, então use a interface apropriada retornada por get_Value.
O exemplo a seguir aplica uma transição Cut ao primeiro slide de input.pptx. Ele chama set_FromBlack com true através de IOptionalBlackTransition para que a transição comece a partir de uma tela preta.
#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/ISlideShowTransition.h>
#include <DOM/SlideShowTransition/IOptionalBlackTransition.h>
#include <DOM/SlideShowTransition/ITransitionValueBase.h>
#include <DOM/SlideShowTransition/TransitionType.h>
#include <Export/SaveFormat.h>
#include <system/console.h>
#include <system/object_ext.h>
using namespace System;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace Aspose::Slides::SlideShow;
auto presentation = MakeObject<Presentation>(u"input.pptx");
auto transition = presentation->get_Slide(0)->get_SlideShowTransition();
transition->set_Type(TransitionType::Cut);
auto cutTransition = AsCast<IOptionalBlackTransition>(transition->get_Value());
if (cutTransition != nullptr)
{
cutTransition->set_FromBlack(true);
presentation->Save(u"cut-from-black.pptx", SaveFormat::Pptx);
}
else
{
Console::WriteLine(u"Cut transition options are unavailable.");
}
presentation->Dispose();
FAQ
Posso controlar a velocidade de reprodução de uma transição de slide?
Sim. Prefira set_Duration quando precisar de uma duração exata do efeito em milissegundos. Use set_Speed quando uma categoria predefinida de TransitionSpeed — Slow, Medium ou Fast — for suficiente e nenhuma duração explícita for definida. Essas configurações controlam o efeito de transição independentemente do atraso de avanço automático.
Posso anexar áudio a uma transição e fazê‑lo repetir?
Sim. Atribua áudio incorporado com set_Sound, chame set_SoundMode com StartSound da enumeração TransitionSoundMode, e habilite a repetição com set_SoundLoop. O áudio se repete até o próximo evento sonoro na apresentação de slides.
Qual a maneira mais rápida de aplicar a mesma transição a todos os slides?
Percorra a coleção retornada pelo método get_Slides da apresentação e chame set_Type com o mesmo valor para a transição de cada slide. Defina quaisquer opções de tempo e efeito no mesmo loop para manter o comportamento consistente entre os slides.
Como posso verificar qual transição está atualmente definida em um slide?
Chame get_Type na transição retornada pelo método get_SlideShowTransition do slide. Ele retorna um valor da enumeração TransitionType; None significa que nenhum efeito de transição foi aplicado.