Adicionar XPS de transparência de grade de gradiente

Os arquivos XPS podem ser usados para exibir muitas informações visuais. Eles suportam texto, imagens, transparência de objetos, grades, gradientes e muitos outros recursos. Você pode inserir objetos de gradiente, grade e transparentes em arquivos XPS conforme suas necessidades. Neste artigo, exploraremos esses recursos em detalhes, juntamente com diferentes exemplos e casos de uso. Vamos percorrer os seguintes tópicos:

Instalando a API XPS para C++

Você pode configurar rápida e facilmente a API Aspose.Page for C++ em seus aplicativos de programação para manipular XPS, PS, EPS e outros formatos de arquivo suportados. Basta baixar o arquivo DLL do oficial Downloads, ou instalá-lo da galeria NuGet com o comando abaixo:

PM> Install-Package Aspose.Page.Cpp 

Adicionando gradiente no arquivo XPS usando C++

Às vezes você precisa adicionar gradiente em arquivos XPS. Você pode manipular o arquivo XPS, pois a API permite adicionar gradiente linear, horizontal e vertical. Vamos adicionar os seguintes gradientes em um arquivo XPS:

Adicionar gradiente vertical no arquivo XPS com C++

Você pode facilmente adicionar gradiente vertical em arquivos XPS com algumas chamadas de API simples. Abaixo estão as etapas para adicionar o gradiente vertical:

  1. Crie um novo Documento XPS
  2. Inicialize a lista de XpsGradientStop
  3. Crie um novo caminho definindo a geometria
  4. Salvar documento XPS resultante

O código abaixo é baseado nestas etapas, que demonstram como adicionar um gradiente vertical em um arquivo XPS usando C++:

// Criar novo documento XPS
auto doc = System::MakeObject<XpsDocument>();

// Inicialize a 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));

// Crie um novo caminho definindo a geometria na forma de abreviação
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);

// Salvar documento XPS resultante
doc->Save(RunExamples::outDir() + u"AddVerticalGradient_out.xps");

Adicionar gradiente horizontal em XPS usando C++

Outra possível variação de gradiente em arquivos XPS é o gradiente horizontal. A abordagem de adicionar gradiente horizontal está um pouco relacionada ao caso de uso que discutimos acima. A seguir estão as etapas que você precisa seguir para adicionar gradiente horizontal:

  1. Criar novo documento XPS
  2. Especifique paradas de gradiente usando XpsGradientStop
  3. Criar caminho com geometria
  4. Salvar documento XPS de saída

O trecho de código a seguir explica como adicionar gradiente horizontal em arquivos XPS usando C++:

// Criar novo documento XPS
auto doc = System::MakeObject<XpsDocument>();

// Inicialize a 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));

// Crie um novo caminho definindo a geometria em forma de abreviação
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);

// Salvar documento XPS resultante
doc->Save(RunExamples::outDir() + u"AddHorizontalGradient_out.xps");

Inserir grade no arquivo XPS com C++

Aspose.Page for C++ API permite renderizar grades nos arquivos XPS com muitas propriedades para controlar a renderização. Vamos considerar o exemplo de inserção de grade no arquivo XPS em seus aplicativos baseados em C++. Você pode trabalhar com esse recurso considerando as etapas abaixo:

  1. Inicialize o objeto da classe XpsDocument
  2. Especifique a geometria para a grade VisualBrush
  3. Criar Canvas para grade magenta VisualBrush
  4. Criar pincel visual e adicionar grade
  5. Salvar arquivo XPS de saída

O código abaixo é baseado nestas etapas que explicam como inserir grade em arquivos XPS usando C++:

auto doc = System::MakeObject<XpsDocument>();

// Geometria para grade 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));

// Tela para grade 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);

//Criar Visual Brush, é especificado por algum fragmento XPS (gráficos vetoriais e 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);

// Nova tela
System::SharedPtr<XpsCanvas> canvas = doc->AddCanvas();
canvas->set_RenderTransform(doc->CreateMatrix(1.f, 0.f, 0.f, 1.f, 268.f, 70.f));

// Adicionar grade
canvas->AddPath(gridPath);

// Retângulo transparente vermelho no topo do meio
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);

// Salvar documento XPS resultante
doc->Save(RunExamples::outDir() + u"AddGrid_out.xps");

Inserir objeto transparente no arquivo XPS usando C++

Outro recurso interessante para trabalhar com arquivos XPS é o suporte para transparência e opacidade. Pode ser necessário adicionar objetos transparentes ao arquivo XPS em diferentes cenários. Isso pode ser alcançado com a ajuda dos seguintes passos:

  1. Criar novo Documento XPS
  2. Criar caminho com geometria retangular fechada
  3. Adicione geometria para caminhos diferentes
  4. Salvar documento XPS de saída

Essas etapas são seguidas pelo código a seguir, que demonstra como adicionar um objeto transparente em um arquivo XPS com a linguagem de programação C++:

// Criar novo documento XPS
auto doc = System::MakeObject<XpsDocument>();

// Apenas para demonstrar transparência
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()));

// Criar caminho com geometria retangular fechada
System::SharedPtr<XpsPath> path1 = doc->CreatePath(doc->CreatePathGeometry(u"M20,20 h200 v200 h-200 z"));
// Defina o pincel sólido azul para preencher o caminho1
path1->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Blue()));
// Adicione-o à página atual
System::SharedPtr<XpsPath> path2 = doc->Add(path1);

// path1 e path2 são os mesmos assim que path1 não foi colocado dentro de nenhum outro elemento
// (o que significa que path1 não tinha elemento pai).
// Por causa da cor desse retângulo na página, efetivamente fica verde
path2->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Green()));

// Agora adicione path2 mais uma vez. Agora path2 tem pai. Então path3 não será o mesmo que path2.
// Assim, um novo retângulo é pintado na página...
System::SharedPtr<XpsPath> path3 = doc->Add(path2);
// ... e nós mudamos 300 unidades para baixo ...
path3->set_RenderTransform(doc->CreateMatrix(1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 300.0f));
// ... e defina o pincel sólido vermelho para preenchê-lo
path3->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Red()));

// Crie um novo path4 com a geometria do path2 ...
System::SharedPtr<XpsPath> path4 = doc->AddPath(path2->get_Data());
// ... desloque 300 unidades para a direita ...
path4->set_RenderTransform(doc->CreateMatrix(1.0f, 0.0f, 0.0f, 1.0f, 300.0f, 0.0f));
// ... e defina o preenchimento sólido azul
path4->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Blue()));

// Adicione path4 mais uma vez.
System::SharedPtr<XpsPath> path5 = doc->Add(path4);
// path4 e path5 não são os mesmos novamente ...
// (mover caminho5 300 unidades para baixo)
path5->set_RenderTransform(path5->get_RenderTransform()->Clone());
// para desconectar o valor RenderTransform do path4 (veja o próximo comentário sobre a propriedade Fill)
path5->get_RenderTransform()->Translate(0.0f, 300.0f);
// ... mas se definirmos a opacidade da propriedade Fill, ela terá efeito tanto no path5 quanto no path4
// porque brush é um valor de propriedade complexo que permanece o mesmo para path5 e path4
path5->get_Fill()->set_Opacity(0.8f);

// Crie um novo path6 com a geometria do path2 ...
System::SharedPtr<XpsPath> path6 = doc->AddPath(path2->get_Data());
// ... desloque 600 unidades para a direita ...
path6->set_RenderTransform(doc->CreateMatrix(1.0f, 0.0f, 0.0f, 1.0f, 600.0f, 0.0f));
// ... e defina o preenchimento sólido amarelo
path6->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Yellow()));

// Agora adicione o clone do path6 ...
System::SharedPtr<XpsPath> path7 = doc->Add(path6->Clone());
// (mover caminho5 300 unidades para baixo)
path7->set_RenderTransform(path7->get_RenderTransform()->Clone());
path7->get_RenderTransform()->Translate(0.0f, 300.0f);
// ... e defina a opacidade para path7
path7->get_Fill()->set_Opacity(0.8f);
// Agora a opacidade afeta independentemente assim que os valores da propriedade são clonados junto com o elemento

// O bloco de código a seguir é equivalente ao anterior.
// Adicione o próprio path6. path6 e path7 não são os mesmos. Embora seus valores de propriedade Fill sejam os mesmos 
//XpsPath path7 = doc.Add(path6);
//path7.RenderTransform = path7.RenderTransform.Clone();
//path7.RenderTransform.Translate(0, 300);
// Para "desconectar" a propriedade Fill do path7 da propriedade Fill do path6, reatribua-a ao seu clone (ou ao clone Fill do path6)
//path7.Fill = ((XpsSolidColorBrush)path7.Fill).Clone();
//path7.Fill.Opacity = 0.8f;

// Salvar documento XPS resultante
doc->Save(RunExamples::outDir() + u"WorkingWithTransparency_out.xps");

Conclusão

Em poucas palavras, exploramos vários recursos para trabalhar com arquivos XPS. Você pode adicionar um gradiente, linear, horizontal ou vertical, bem como grades ou objetos transparentes em arquivos XPS. Além disso, você pode dar uma olhada em vários outros recursos baixando o Examples project. Em caso de qualquer ambiguidade, sinta-se à vontade para nos escrever nos Fóruns de Suporte Gratuito. Ficaremos honrados em orientá-lo!

Veja também