Utilização de utilitários gráficos XPS | C++

Como produzir facilmente formas simples em XPS

A especificação XPS define elementos gráficos primitivos que podem ser utilizados para compor qualquer forma complexa. O Aspose.Page para C++ disponibiliza classes que encapsulam estes elementos. No entanto, a sua utilização pode ser um pouco tedioso quando é necessário produzir formas relativamente simples, como um setor ou segmento circular, ou um n-gono regular inscrito ou circunscrito num círculo. Mesmo desenhar um círculo ou uma elipse não é tão simples como poderia e provavelmente deveria ser. É por isso que o Aspose.Page também fornece um conjunto de métodos utilitários que provavelmente lhe pouparão tempo ao executar tais tarefas.

No exemplo seguinte, utilizamos todos os utilitários de forma disponíveis. Note-se que todos eles devolvem um objeto de XpsPathGeometry, que pode ser utilizado para construir caminhos XPS. E para estes caminhos, pode especificar propriedades de aparência — pincéis, padrão de traçado, opacidade, etc.

    // ExStart:UsingShapeUtils
    // For complete examples and data files, please go to https://github.com/aspose-page/Aspose.Page-for-C
    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithShapes();
    // Create new XPS Document
    {
        System::SharedPtr<XpsDocument> doc = System::MakeObject<XpsDocument>();
        // Clearing resources under 'using' statement
        System::Details::DisposeGuard<1> __dispose_guard_0({ doc});
        // ------------------------------------------
        
        try
        {
            // Set first page's size.
            doc->get_Page()->set_Width(650.f);
            doc->get_Page()->set_Height(240.f);
            
            // Draw a circle with center (120, 120) and radius 100.
            System::SharedPtr<XpsPath> path = doc->CreatePath(doc->get_Utils()->CreateCircle(System::Drawing::PointF(120.f, 120.f), 100.f));
            path->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Green()));
            doc->Add<System::SharedPtr<XpsPath>>(path);
            
            // Inscribe a regular pentagon in the circle.
            path = doc->CreatePath(doc->get_Utils()->CreateRegularInscribedNGon(5, System::Drawing::PointF(120.f, 120.f), 100.f));
            path->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Red()));
            doc->Add<System::SharedPtr<XpsPath>>(path);
            
            // Circumscribe a regular hexagon around the circle.
            path = doc->CreatePath(doc->get_Utils()->CreateRegularCircumscribedNGon(6, System::Drawing::PointF(120.f, 120.f), 100.f));
            path->set_Stroke(doc->CreateSolidColorBrush(System::Drawing::Color::get_Magenta()));
            path->set_StrokeThickness(3.f);
            doc->Add<System::SharedPtr<XpsPath>>(path);
            
            // Draw a sector of the circle centered at (340, 120), starting at -45 degrees and ending at +45 degrees.
            path = doc->CreatePath(doc->get_Utils()->CreatePieSlice(System::Drawing::PointF(340.f, 120.f), 100.f, -45.f, 45.f));
            path->set_Stroke(doc->CreateSolidColorBrush(System::Drawing::Color::get_Red()));
            path->set_StrokeThickness(5.f);
            doc->Add<System::SharedPtr<XpsPath>>(path);
            
            // Draw a segment of the circle centered at (340, 120), starting at -45 degrees and ending at +45 degrees.
            path = doc->CreatePath(doc->get_Utils()->CreateCircularSegment(System::Drawing::PointF(340.f, 120.f), 100.f, -45.f, 45.f));
            path->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Black()));
            doc->Add<System::SharedPtr<XpsPath>>(path);
            
            // Draw a rectangle with the top left vertex (530, 20), width 100 units and height 200 units.
            path = doc->CreatePath(doc->get_Utils()->CreateRectangle(System::Drawing::RectangleF(530.f, 20.f, 100.f, 200.f)));
            path->set_Stroke(doc->CreateSolidColorBrush(System::Drawing::Color::get_Red()));
            doc->Add<System::SharedPtr<XpsPath>>(path);
            
            // Draw an ellipse with center (580, 120) and radii 50 and 100.
            path = doc->CreatePath(doc->get_Utils()->CreateEllipse(System::Drawing::PointF(580.f, 120.f), 50.f, 100.f));
            path->set_Fill(doc->CreateSolidColorBrush(System::Drawing::Color::get_Yellow()));
            doc->Add<System::SharedPtr<XpsPath>>(path);
            
            doc->Save(dataDir + u"UseShapeUtilsXPS_out.xps");
        }
        catch(...)
        {
            __dispose_guard_0.SetCurrentException(std::current_exception());
        }
    }
    // ExEnd:UsingShapeUtils

Começamos por um novo documento XPS, ajustando depois o tamanho da primeira página. A primeira forma que colocamos na página é um círculo (especificado pelo seu centro e raio) preenchido com um verde sólido. Em seguida, inscrevemos um pentágono regular vermelho sem preenchimento nesse círculo. Em seguida, surge um hexágono regular circunscrito com contorno magenta.

À direita, desenhamos primeiro um sector circular vermelho (ou uma “fatia de pizza”) entre -45 e +45 graus e, em seguida, um segmento circular preto com os mesmos parâmetros sobre o sector.

A última parte do desenho é constituída por um retângulo vermelho (especificado pelo vértice superior esquerdo e pelas dimensões) e por uma elipse amarela (especificada pelo centro e pelos raios), inscrita no retângulo. Aqui, controlamos a inscrição “manualmente”.

Eis o que devemos ver no ficheiro XPS guardado:

Como adicionar facilmente uma imagem numa página XPS

Com as primitivas definidas pela especificação XPS, a adição de uma imagem a uma página consiste em dois passos:

• Adicionar um caminho retangular que pretende preencher com a imagem;
• Definir um pincel de imagem para o caminho, onde é necessário especificar uma caixa de visualização e uma janela de visualização. Geralmente, terá de saber a resolução e o tamanho em pixéis da sua imagem para fornecer os dois primeiros parâmetros com precisão.

Mas, felizmente, existe um método conveniente entre os utilitários gráficos XPS da API Aspose.Page para C++ que pode fazer (quase) todo o trabalho por si. Também oferece vários modos de ajuste. Vejamos o exemplo abaixo:

    // ExStart:UsingImageUtils
    // For complete examples and data files, please go to https://github.com/aspose-page/Aspose.Page-for-C
    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithImages();
    // Create new XPS Document
    {
        System::SharedPtr<XpsDocument> doc = System::MakeObject<XpsDocument>();
        // Clearing resources under 'using' statement
        System::Details::DisposeGuard<1> __dispose_guard_0({ doc});
        // ------------------------------------------
        
        try
        {
            // Set first page's size.
            doc->get_Page()->set_Width(540.f);
            doc->get_Page()->set_Height(220.f);
            
            // Draw the image box.
            System::Drawing::RectangleF imageBox(10.f, 10.f, 200.f, 200.f);
            System::SharedPtr<XpsPath> path = doc->AddPath(doc->get_Utils()->CreateRectangle(imageBox));
            path->set_Stroke(doc->CreateSolidColorBrush(System::Drawing::Color::get_Black()));
            // Add an image to fit width.
            path = doc->get_Utils()->CreateImage(dataDir + u"R08LN_NN.jpg", imageBox, Aspose::Page::XPS::ImageMode::FitToWidth);
            // Prevent tiling.
            (System::ExplicitCast<Aspose::Page::XPS::XpsModel::XpsImageBrush>(path->get_Fill()))->set_TileMode(Aspose::Page::XPS::XpsModel::XpsTileMode::None);
            doc->Add<System::SharedPtr<XpsPath>>(path);
            
            // Add an image to fit width.
            doc->Add<System::SharedPtr<XpsPath>>(doc->get_Utils()->CreateImage(dataDir + u"R08LN_NN.jpg", System::Drawing::RectangleF(220.f, 10.f, 200.f, 100.f), Aspose::Page::XPS::ImageMode::FitToHeight));
            
            // Add an image to fit width.
            doc->Add<System::SharedPtr<XpsPath>>(doc->get_Utils()->CreateImage(dataDir + u"R08LN_NN.jpg", System::Drawing::RectangleF(430.f, 10.f, 100.f, 200.f), Aspose::Page::XPS::ImageMode::FitToBox));
            
            // Save resultant XPS document 
            doc->Save(dataDir + u"UseImageUtilsXPS_out.xps");
        }
        catch(...)
        {
            __dispose_guard_0.SetCurrentException(std::current_exception());
        }
    }
    // ExEnd:UsingImageUtils

Mais uma vez, começamos com um novo documento XPS e ajustamos o tamanho da primeira página. De notar que, por defeito, a imagem utilizada como pincel se dividirá em blocos na área retangular da mesma forma que se fosse utilizada no modo XpsTileMode.Tile. No entanto, na primeira parte do exemplo, demonstramos como evitar este agrupamento.

Assim, primeiro queremos que a imagem apareça em (10, 10) e se ajuste à largura da caixa retangular, que tem 200 unidades de largura e 200 unidades de altura. Para ver o resultado com mais clareza, primeiro desenhamos a própria caixa. De seguida, criamos a imagem (note-se que, na verdade, é um caminho preenchido). Por fim, após obter o preenchimento do caminho e convertê-lo para XpsImageBrush, definimos a propriedade TileMode como XpsTileMode.None.

À direita, posicionamos a mesma imagem e ajustamo-la à altura da caixa de imagem. Observe o mosaico.

Por fim, posicionamos novamente a mesma imagem à direita e ajustamo-la à altura e à largura da caixa de imagem, o que distorce a imagem.

E aqui está o resultado no ficheiro XPS guardado: