Gestionar transiciones de diapositivas en presentaciones usando C++
Resumen
Las transiciones de diapositivas controlan cómo aparecen las diapositivas durante una presentación. Con Aspose.Slides para C++, puedes elegir un efecto de transición para cada diapositiva, configurar el avance mediante clic del ratón o temporizador, y ajustar opciones específicas de un efecto. Este artículo utiliza ejemplos en C++ para aplicar transiciones, establecer duraciones exactas de transición, gestionar el tiempo de la diapositiva y crear una transición Morph entre dos diapositivas. Los ejemplos también muestran cómo guardar la configuración en un archivo PPTX.
Agregar transición de diapositiva
Para aplicar una transición, carga una presentación con la clase Presentation y accede a la configuración de transición de una diapositiva a través de get_SlideShowTransition. Llama a set_Type con un valor de la enumeración TransitionType, y luego guarda la presentación.
El siguiente ejemplo aplica una transición Circle a la primera diapositiva y una transición Comb a la segunda. Usa un archivo input.pptx con al menos dos diapositivas.
#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();
Transición de rueda
El método set_Spokes de IWheelTransition controla el número de sectores radiales que revelan la diapositiva de destino. Llama a set_Type con Wheel de TransitionType antes de acceder a get_Value como IWheelTransition.
Este ejemplo crea dos pares idénticos de diapositivas: una diapositiva negra seguida de una diapositiva con un rectángulo dorado. Las diapositivas de destino utilizan recuentos de radios de 1 y 8, con la misma velocidad establecida mediante set_Speed y una duración explícita de 8 000 milisegundos establecida mediante set_Duration, para que la diferencia sea 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();
Abre la presentación de salida en PowerPoint y ejecuta la presentación de diapositivas. Avanza de la diapositiva 1 a la diapositiva 2, y luego de la diapositiva 3 a la diapositiva 4. En la reproducción de PowerPoint, el recuento de radios verificado de 1 revela la diapositiva con un barrido horario; el recuento verificado de 8 la revela mediante ocho sectores radiales simultáneamente. El contenido de destino y el tiempo de transición son idénticos, por lo que la diferencia es el número de sectores de revelado.
Agregar transición de diapositiva avanzada
Puedes configurar cuánto tiempo permanece una diapositiva en pantalla y si un clic del ratón avanza la presentación. Los siguientes métodos controlan este comportamiento:
- set_AdvanceOnClick permite al espectador avanzar haciendo clic con el ratón.
- set_AdvanceAfter habilita el avance automático.
- set_AdvanceAfterTime especifica el retraso antes del avance automático, en milisegundos.
Habilita tanto el avance mediante clic como el temporizado para que el espectador continúe con un clic o espere al temporizador. Para usar solo el temporizador, llama a set_AdvanceOnClick con false. El retraso controla cuándo avanza la presentación; no establece la duración del efecto visual de transición.
Este ejemplo asigna diferentes efectos a las tres primeras diapositivas y habilita el avance automático después de 3, 5 y 7 segundos, respectivamente. Los clics del ratón también pueden avanzar estas diapositivas. Usa un archivo input.pptx con al menos tres diapositivas.
#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 comprobar si el avance temporizado está habilitado, llama a get_AdvanceAfter. Un retraso almacenado por sí solo no indica que el temporizador esté activo.
El siguiente ejemplo abre el archivo guardado anteriormente, informa de cada temporizador habilitado y desactiva el avance automático para las diapositivas con un retraso superior a dos segundos. Habilita los clics del ratón para esas diapositivas y guarda la configuración actualizada.
#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 el tiempo de la transición con precisión
Utiliza set_Duration para especificar la duración exacta de un efecto de transición en milisegundos. El método get_SlideShowTransition de la diapositiva expone estas configuraciones a través de ISlideShowTransition:
| Método | Propósito |
|---|---|
| set_Duration | Establece la duración del propio efecto de transición, en milisegundos. |
| set_AdvanceAfterTime | Establece el retraso antes de que la diapositiva avance automáticamente, en milisegundos. Llama a set_AdvanceAfter con true para activar este temporizador. |
| set_Speed | Selecciona una categoría de velocidad predefinida de TransitionSpeed: Slow, Medium o Fast. Se utiliza cuando no se especifica una duración exacta. |
set_Duration controla solo el efecto de transición; no determina cuánto tiempo permanece visible la diapositiva. Configura el retraso del avance automático por separado. Cuando no se establece una duración explícita, Aspose.Slides determina la duración del efecto a partir del tipo de transición y el valor devuelto por get_Speed.
El ejemplo compartido asigna a cada diapositiva una transición Fade de 750 ms y habilita por separado el avance automático a 5 000 ms. La duración de la transición controla el efecto; el avance controla cuándo salir de la diapositiva. Estas barras son configuraciones esquemáticas, no una línea de tiempo combinada medida.
Aplicar la misma duración a cada diapositiva
Para lograr un ritmo constante, aplica el mismo efecto y la misma duración exacta a cada diapositiva. Este ejemplo carga input.pptx, selecciona Fade de TransitionType, y asigna a cada transición una duración de 750 milisegundos. Habilita por separado el avance automático después de 5 000 milisegundos y desactiva el avance mediante clic del ratón, y luego guarda el 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 el avance automático independientemente de la duración del efecto.
transition->set_AdvanceAfter(true);
transition->set_AdvanceAfterTime(5000);
transition->set_AdvanceOnClick(false);
}
presentation->Save(u"precise-transitions.pptx", SaveFormat::Pptx);
presentation->Dispose();
Establecer duraciones diferentes para diapositivas individuales
Diferentes diapositivas pueden usar duraciones de efecto distintas. Por ejemplo, utiliza una transición breve para una diapositiva de título y una transición más larga para la introducción de una sección. Este ejemplo establece 500 milisegundos para la primera diapositiva y 1 200 milisegundos para la segunda. Usa un archivo input.pptx con al menos dos diapositivas.
#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();
Coordinar transiciones con salida animada
Cuando prepares un GIF animado, una presentación HTML5, o un vídeo, establece duraciones exactas de transición antes de exportar para que coincidan con el ritmo deseado. Por ejemplo, utiliza un fundido de 600 milisegundos entre escenas y ajusta el retraso de avance de cada diapositiva por separado para permitir tiempo a su narración o contenido.
Para GIF y vídeo, coordina la velocidad de fotogramas de salida con la duración del efecto: 600 milisegundos corresponden a 18 fotogramas a 30 fotogramas por segundo. En HTML5, habilita transiciones animadas en la configuración de exportación. Verifica los efectos y opciones de temporización soportados por el formato de exportación elegido y previsualiza la salida para confirmar la sincronización.
Leer la duración de una transición existente
Llama a get_Duration antes de modificar la transición para determinar si se almacena un valor explícito. Un valor de -1 significa que no se ha establecido una duración explícita; un valor no negativo especifica la duración almacenada en milisegundos. El valor no establecido no es la duración de reproducción calculada: Aspose.Slides utiliza el tipo de transición y el valor devuelto por get_Speed para determinar esa duración. Establecer un tipo de transición puede inicializar una duración, así que inspecciona primero la configuración original.
#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();
Transición Morph
La transición Morph anima los cambios entre objetos en diapositivas consecutivas. Para crear un efecto Morph sencillo, clona una diapositiva, mueve o redimensiona un objeto en la copia, y aplica la transición Morph a la segunda diapositiva. Esto proporciona a la transición los objetos correspondientes para animar entre sus estados original y modificado.
El siguiente ejemplo crea una diapositiva con un rectángulo de texto, clona la diapositiva y cambia la posición y el tamaño del rectángulo en la copia. Luego selecciona Morph de la enumeración TransitionType para la segunda diapositiva. Abre el archivo guardado en un visor de presentaciones que admita Morph para ver el efecto durante la presentación.
#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 transición Morph
La enumeración TransitionMorphType controla cómo Morph coincide y anima el contenido:
- ByObject trata cada forma como un objeto completo.
- ByWord anima el texto coincidiendo palabras cuando sea posible.
- ByChar anima el texto coincidiendo caracteres cuando sea posible.
Llama a set_Type con Morph antes de acceder a get_Value. El valor proporciona entonces la interfaz IMorphTransition, cuyo método set_MorphType selecciona el modo de coincidencia.
#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();
Establecer efectos de transición
Algunas transiciones exponen opciones adicionales, como la dirección o si el efecto comienza desde una pantalla negra. Las opciones disponibles dependen del tipo de transición seleccionado. Establece primero el tipo y luego utiliza la interfaz adecuada devuelta por get_Value.
El siguiente ejemplo aplica una transición Cut a la primera diapositiva de input.pptx. Llama a set_FromBlack con true mediante IOptionalBlackTransition para que la transición comience desde una pantalla negra.
#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();
Preguntas frecuentes
¿Puedo controlar la velocidad de reproducción de una transición de diapositiva?
Sí. Prefiere set_Duration cuando necesites una duración exacta del efecto en milisegundos. Usa set_Speed cuando una categoría predefinida de TransitionSpeed — Slow, Medium o Fast — sea suficiente y no se haya establecido una duración explícita. Estas configuraciones controlan el efecto de transición de forma independiente del retraso de avance automático.
¿Puedo adjuntar audio a una transición y hacerlo repetir en bucle?
Sí. Asigna audio incrustado con set_Sound, llama a set_SoundMode con StartSound de la enumeración TransitionSoundMode, y habilita el bucle con set_SoundLoop. El audio se reproduce en bucle hasta el siguiente evento de sonido en la presentación.
¿Cuál es la forma más rápida de aplicar la misma transición a todas las diapositivas?
Recorre la colección devuelta por el método get_Slides de la presentación y llama a set_Type con el mismo valor para la transición de cada diapositiva. Establece cualquier opción de temporización y efecto en el mismo bucle para mantener el comportamiento coherente en todas las diapositivas.
¿Cómo puedo comprobar qué transición está establecida actualmente en una diapositiva?
Llama a get_Type sobre la transición devuelta por el método get_SlideShowTransition de la diapositiva. Devuelve un valor de la enumeración TransitionType; None indica que no se ha aplicado ningún efecto de transición.