Los archivos XPS se pueden usar para mostrar mucha información visual. Admiten texto, imágenes, transparencia de objetos, cuadrículas, degradados y muchas otras características. Puede insertar objetos degradados, de cuadrícula y transparentes en archivos XPS según sus requisitos. En este artículo, exploraremos estas características en detalle, junto con diferentes ejemplos y casos de uso. Analicemos los siguientes temas:
- Instalación de la API de XPS para C++
- Agregar degradado en un archivo XPS usando C++
- Insertar cuadrícula en archivo XPS con C++
- Inserte un objeto transparente en un archivo XPS usando C++
Instalación de la API de XPS para C++
Puede configurar rápida y fácilmente la API Aspose.Page for C++ en sus aplicaciones de programación para manipular XPS, PS, EPS y otros formatos de archivo admitidos. Simplemente descargue el archivo DLL de las Descargas oficiales o instálelo desde la galería NuGet con el siguiente comando:
PM> Install-Package Aspose.Page.Cpp
Agregar degradado en un archivo XPS usando C++
A veces es necesario agregar un degradado en los archivos XPS. Puede manipular el archivo XPS ya que la API le permite agregar gradientes lineales, horizontales y verticales. Agreguemos los siguientes gradientes en un archivo XPS:
Agregar degradado vertical en el archivo XPS con C++
Puede agregar fácilmente un degradado vertical en archivos XPS con unas pocas llamadas simples a la API. A continuación se muestran los pasos para agregar el degradado vertical:
- Crear un nuevo Documento XPS
- Inicializar lista de XpsGradientStop
- Crea una nueva ruta definiendo la geometría.
- Guarde el documento XPS resultante
El siguiente código se basa en estos pasos, que demuestra cómo agregar un degradado vertical en un archivo XPS usando C++:
// Crear nuevo documento XPS
auto doc = System::MakeObject<XpsDocument>();
// Inicializar lista de XpsGradientStop
auto stops = System::MakeObject<System::Collections::Generic::List<System::SharedPtr<XpsGradientStop>>>();
stops->Add(doc->CreateGradientStop(doc->CreateColor(253, 255, 12, 0), 0.f));
stops->Add(doc->CreateGradientStop(doc->CreateColor(252, 255, 154, 0), 0.359375f));
stops->Add(doc->CreateGradientStop(doc->CreateColor(252, 255, 56, 0), 0.424805f));
stops->Add(doc->CreateGradientStop(doc->CreateColor(253, 255, 229, 0), 0.879883f));
stops->Add(doc->CreateGradientStop(doc->CreateColor(252, 255, 255, 234), 1.f));
// Cree una nueva ruta definiendo la geometría en forma de abreviatura
System::SharedPtr<XpsPath> path = doc->AddPath(doc->CreatePathGeometry(u"M 10,110 L 228,110 228,200 10,200"));
path->set_RenderTransform(doc->CreateMatrix(1.f, 0.f, 0.f, 1.f, 20.f, 70.f));
path->set_Fill(doc->CreateLinearGradientBrush(System::Drawing::PointF(10.f, 110.f), System::Drawing::PointF(10.f, 200.f)));
(System::DynamicCast<Aspose::Page::Xps::XpsModel::XpsGradientBrush>(path->get_Fill()))->get_GradientStops()->AddRange(stops);
// Guarde el documento XPS resultante
doc->Save(RunExamples::outDir() + u"AddVerticalGradient_out.xps");
Agregar degradado horizontal en XPS usando C++
Otra posible variación del degradado en los archivos XPS es el degradado horizontal. El enfoque de agregar un degradado horizontal está un poco relacionado con el caso de uso que hemos discutido anteriormente. Los siguientes son los pasos que debe seguir para agregar un degradado horizontal:
- Crear nuevo documento XPS
- Especifique paradas de degradado usando XpsGradientStop
- Crear ruta con geometría
- Guardar documento XPS de salida
El siguiente fragmento de código explica cómo agregar un degradado horizontal en archivos XPS usando C++:
// Crear nuevo documento XPS
auto doc = System::MakeObject<XpsDocument>();
// Inicializar lista de XpsGradientStop
System::SharedPtr<System::Collections::Generic::List<System::SharedPtr<XpsGradientStop>>> stops = System::MakeObject<System::Collections::Generic::List<System::SharedPtr<XpsGradientStop>>>();
stops->Add(doc->CreateGradientStop(doc->CreateColor(255, 244, 253, 225), 0.0673828f));
stops->Add(doc->CreateGradientStop(doc->CreateColor(255, 251, 240, 23), 0.314453f));
stops->Add(doc->CreateGradientStop(doc->CreateColor(255, 252, 209, 0), 0.482422f));
stops->Add(doc->CreateGradientStop(doc->CreateColor(255, 241, 254, 161), 0.634766f));
stops->Add(doc->CreateGradientStop(doc->CreateColor(255, 53, 253, 255), 0.915039f));
stops->Add(doc->CreateGradientStop(doc->CreateColor(255, 12, 91, 248), 1.f));
// Cree una nueva ruta definiendo la geometría en forma de abreviatura
System::SharedPtr<XpsPath> path = doc->AddPath(doc->CreatePathGeometry(u"M 10,210 L 228,210 228,300 10,300"));
path->set_RenderTransform(doc->CreateMatrix(1.f, 0.f, 0.f, 1.f, 20.f, 70.f));
path->set_Fill(doc->CreateLinearGradientBrush(System::Drawing::PointF(10.f, 0.f), System::Drawing::PointF(228.f, 0.f)));
(System::DynamicCast<Aspose::Page::Xps::XpsModel::XpsGradientBrush>(path->get_Fill()))->get_GradientStops()->AddRange(stops);
// Guarde el documento XPS resultante
doc->Save(RunExamples::outDir() + u"AddHorizontalGradient_out.xps");
Insertar cuadrícula en archivo XPS con C++
Aspose.Page for C++ le permite renderizar cuadrículas en los archivos XPS con muchas propiedades para controlar el renderizado. Consideremos el ejemplo de insertar una cuadrícula en un archivo XPS en sus aplicaciones basadas en C++. Puede trabajar con esta función considerando los pasos a continuación:
- Inicializar objeto de clase XpsDocument
- Especificar geometría para la cuadrícula VisualBrush
- Crear Lienzo para cuadrícula magenta VisualBrush
- Crear pincel visual y agregar cuadrícula
- Guardar archivo XPS de salida
El siguiente código se basa en estos pasos que explican cómo insertar una cuadrícula en archivos XPS usando C++:
auto doc = System::MakeObject<XpsDocument>();
// Geometría para cuadrícula magenta VisualBrush
System::SharedPtr<XpsPathGeometry> pathGeometry = doc->CreatePathGeometry();
pathGeometry->AddSegment(doc->CreatePolyLineSegment(System::MakeArray<System::Drawing::PointF>({ System::Drawing::PointF(240.f, 5.f), System::Drawing::PointF(240.f, 310.f), System::Drawing::PointF(0.f, 310.f) })));
pathGeometry->idx_get(0)->set_StartPoint(System::Drawing::PointF(0.f, 5.f));
// Lienzo para cuadrícula magenta VisualBrush
System::SharedPtr<XpsCanvas> visualCanvas = doc->CreateCanvas();
System::SharedPtr<XpsPath> visualPath = visualCanvas->AddPath(doc->CreatePathGeometry(u"M 0,4 L 4,4 4,0 6,0 6,4 10,4 10,6 6,6 6,10 4,10 4,6 0,6 Z"));
visualPath->set_Fill(doc->CreateSolidColorBrush(doc->CreateColor(1.f, .61f, 0.1f, 0.61f)));
System::SharedPtr<XpsPath> gridPath = doc->CreatePath(pathGeometry);
//Crear pincel visual, se especifica mediante algún fragmento XPS (gráficos vectoriales y glifos)
gridPath->set_Fill(doc->CreateVisualBrush(visualCanvas, System::Drawing::RectangleF(0.f, 0.f, 10.f, 10.f), System::Drawing::RectangleF(0.f, 0.f, 10.f, 10.f)));
(System::DynamicCast<Aspose::Page::Xps::XpsModel::XpsVisualBrush>(gridPath->get_Fill()))->set_TileMode(Aspose::Page::Xps::XpsModel::XpsTileMode::Tile);
// lienzo nuevo
System::SharedPtr<XpsCanvas> canvas = doc->AddCanvas();
canvas->set_RenderTransform(doc->CreateMatrix(1.f, 0.f, 0.f, 1.f, 268.f, 70.f));
// Agregar cuadrícula
canvas->AddPath(gridPath);
// Rectángulo transparente rojo en la parte superior media
System::SharedPtr<XpsPath> path = canvas->AddPath(doc->CreatePathGeometry(u"M 30,20 l 258.24,0 0,56.64 -258.24,0 Z"));
path = canvas->AddPath(doc->CreatePathGeometry(u"M 10,10 L 228,10 228,100 10,100"));
path->set_Fill(doc->CreateSolidColorBrush(doc->CreateColor(1.0f, 0.0f, 0.0f)));
path->set_Opacity(0.7f);
// Guarde el documento XPS resultante
doc->Save(RunExamples::outDir() + u"AddGrid_out.xps");
Inserte un objeto transparente en un archivo XPS usando C++
Otra característica interesante para trabajar con archivos XPS es la compatibilidad con la transparencia y la opacidad. Es posible que deba agregar objetos transparentes en el archivo XPS en diferentes escenarios. Esto se puede lograr con la ayuda de los siguientes pasos:
- Crear nuevo Documento XPS
- Crear ruta con geometría de rectángulo cerrado
- Agregar geometría para diferentes caminos
- Guardar documento XPS de salida
Estos pasos son seguidos por el siguiente código, que demuestra cómo agregar un objeto transparente en un archivo XPS con el lenguaje de programación C++:
// Crear nuevo documento XPS
auto doc = System::MakeObject<XpsDocument>();
// Solo para demostrar transparencia.
doc->AddPath(doc->CreatePathGeometry(u"M120,0 H400 v1000 H120"))->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Gray()));
doc->AddPath(doc->CreatePathGeometry(u"M300,120 h600 V420 h-600"))->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Gray()));
// Crear ruta con geometría de rectángulo cerrado
System::SharedPtr<XpsPath> path1 = doc->CreatePath(doc->CreatePathGeometry(u"M20,20 h200 v200 h-200 z"));
// Establecer pincel sólido azul para llenar ruta1
path1->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Blue()));
// Agregarlo a la página actual
System::SharedPtr<XpsPath> path2 = doc->Add(path1);
// path1 y path2 son iguales siempre que path1 no se haya colocado dentro de ningún otro elemento
// (lo que significa que path1 no tenía ningún elemento principal).
// Debido al color de ese rectángulo en la página, efectivamente se vuelve verde.
path2->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Green()));
// Ahora agregue path2 una vez más. Ahora path2 tiene padre. Entonces path3 no será lo mismo que path2.
// Así se pinta un nuevo rectángulo en la página...
System::SharedPtr<XpsPath> path3 = doc->Add(path2);
// ... y lo desplazamos 300 unidades más abajo ...
path3->set_RenderTransform(doc->CreateMatrix(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 300.0f));
// ... y coloque un pincel sólido rojo para llenarlo
path3->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Red()));
// Crear nuevo path4 con la geometría de path2...
System::SharedPtr<XpsPath> path4 = doc->AddPath(path2->get_Data());
// ... muévalo 300 unidades a la derecha ...
path4->set_RenderTransform(doc->CreateMatrix(1.0f, 0.0f, 0.0f, 1.0f, 300.0f, 0.0f));
// ... y establece relleno sólido azul
path4->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Blue()));
// Agregue path4 una vez más.
System::SharedPtr<XpsPath> path5 = doc->Add(path4);
// path4 y path5 no vuelven a ser lo mismo...
// (mover path5 300 unidades más abajo)
path5->set_RenderTransform(path5->get_RenderTransform()->Clone());
// para desconectar el valor de RenderTransform de la ruta 4 (ver el siguiente comentario sobre la propiedad de relleno)
path5->get_RenderTransform()->Translate(0.0f, 300.0f);
// ... pero si establecemos la opacidad de la propiedad Relleno, tendrá efecto tanto en la ruta 5 como en la ruta 4
// porque brush es un valor de propiedad complejo que sigue siendo el mismo para path5 y path4
path5->get_Fill()->set_Opacity(0.8f);
// Crear nuevo path6 con la geometría de path2...
System::SharedPtr<XpsPath> path6 = doc->AddPath(path2->get_Data());
// ... muévelo 600 unidades a la derecha ...
path6->set_RenderTransform(doc->CreateMatrix(1.0f, 0.0f, 0.0f, 1.0f, 600.0f, 0.0f));
// ... y establece relleno sólido amarillo
path6->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Yellow()));
// Ahora agrega el clon de path6...
System::SharedPtr<XpsPath> path7 = doc->Add(path6->Clone());
// (mover path5 300 unidades más abajo)
path7->set_RenderTransform(path7->get_RenderTransform()->Clone());
path7->get_RenderTransform()->Translate(0.0f, 300.0f);
// ... y establece la opacidad para path7
path7->get_Fill()->set_Opacity(0.8f);
// Ahora la opacidad afecta de forma independiente tan pronto como los valores de propiedad se clonan junto con el elemento.
// El siguiente bloque de código es equivalente al anterior.
// Agregue path6 en sí mismo. path6 y path7 no son lo mismo. Aunque sus valores de propiedad de relleno son los mismos
//XpsPath ruta7 = doc.Add(ruta6);
//ruta7.RenderTransform = ruta7.RenderTransform.Clone();
//ruta7.RenderTransform.Translate(0, 300);
// Para "desconectar" la propiedad de Relleno de path7 de la propiedad de Relleno de path6, reasignarla a su clon (o al clon de Relleno de path6)
//ruta7.Fill = ((XpsSolidColorBrush)path7.Fill).Clone();
//ruta7.Relleno.Opacidad = 0.8f;
// Guarde el documento XPS resultante
doc->Save(RunExamples::outDir() + u"WorkingWithTransparency_out.xps");
Conclusión
En pocas palabras, hemos explorado una serie de funciones para trabajar con archivos XPS. Puede agregar un degradado, lineal, horizontal o vertical, así como cuadrículas u objetos transparentes en archivos XPS. Además, puede echar un vistazo a otras funciones descargando el Proyecto de ejemplos. En caso de cualquier ambigüedad, no dude en escribirnos a los Foros de soporte gratuitos. ¡Estaremos honrados de guiarlo!