Utilizzo delle utilità grafiche XPS | C++

Come produrre facilmente forme semplici in XPS

La specifica XPS definisce elementi primitivi grafici che possono essere utilizzati per comporre qualsiasi forma complessa. Aspose.Page per C++ fornisce classi che incapsulano questi elementi. Tuttavia, utilizzarli può essere un po’ noioso quando si devono produrre anche forme relativamente semplici, come un settore circolare o un segmento, o un n-gono regolare inscritto o circoscritto a un cerchio. Anche disegnare un cerchio o un’ellisse non è così semplice come potrebbe e probabilmente dovrebbe essere. Per questo motivo Aspose.Page fornisce anche una serie di metodi di utilità che molto probabilmente vi faranno risparmiare tempo durante l’esecuzione di tali attività.

Nell’esempio seguente, utilizziamo tutte le utilità per le forme disponibili. Si noti che tutti restituiscono un oggetto di tipo XpsPathGeometry, che può quindi essere utilizzato per costruire percorsi XPS. Per questi percorsi è possibile specificare le proprietà di aspetto: pennelli, pattern di tratto, opacità, ecc.

    // 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

Iniziamo con un nuovo documento XPS, modificando poi le dimensioni della prima pagina. La prima forma che posizioniamo sulla pagina è un cerchio (specificato dal suo centro e raggio) riempito di verde pieno. Successivamente, inscriviamo un pentagono regolare rosso vuoto in quel cerchio. Segue poi un esagono regolare circoscritto con un contorno magenta.

A destra, disegniamo prima un settore circolare rosso (o una “fetta di torta”) tra -45 e +45 gradi, e poi un segmento circolare nero con gli stessi parametri sopra il settore.

L’ultima parte del disegno consiste in un rettangolo rosso (specificato dal vertice in alto a sinistra e dalle dimensioni) e un’ellisse gialla (specificata dal centro e dai raggi), inscritti nel rettangolo. Qui, controlliamo l’iscrizione “a mano”.

Ecco cosa dovremmo vedere nel file XPS salvato:

Come aggiungere facilmente un’immagine a una pagina XPS

Con le primitive definite dalla specifica XPS, l’aggiunta di un’immagine a una pagina consiste in due passaggi:

• Aggiunta di un tracciato rettangolare che si desidera riempire con l’immagine;
• Impostazione di un pennello immagine per il tracciato, dove è necessario specificare un riquadro di visualizzazione e una finestra di visualizzazione. In genere, è necessario conoscere la risoluzione e le dimensioni in pixel dell’immagine per fornire con precisione i primi due parametri.

Fortunatamente, esiste un metodo pratico tra le utilità grafiche XPS dell’API Aspose.Page per C++ che può svolgere (quasi) tutto il lavoro per voi. Offre anche diverse modalità di adattamento. Diamo un’occhiata all’esempio seguente:

    // 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

Di nuovo, iniziamo con un nuovo documento XPS e regoliamo le dimensioni della prima pagina. È importante notare a questo punto che, per impostazione predefinita, l’immagine utilizzata come pennello verrà suddivisa in tile sull’area rettangolare, proprio come se fosse utilizzata in modalità XpsTileMode.Tile. Tuttavia, nella prima parte dell’esempio, mostriamo come impedire questo tile.

Quindi, vogliamo innanzitutto che l’immagine appaia in (10, 10) e che si adatti alla larghezza del riquadro rettangolare, che è 200 unità di larghezza e 200 unità di altezza. Per visualizzare il risultato più chiaramente, disegniamo prima il riquadro stesso. Successivamente, creiamo l’immagine (si noti che in realtà è un tracciato riempito). Infine, dopo aver ottenuto il riempimento del tracciato e averlo convertito in XpsImageBrush, impostiamo la proprietà TileMode su XpsTileMode.None.

A destra, posizioniamo la stessa immagine e la adattiamo all’altezza del riquadro immagine. Notate la suddivisione in sezioni.

Infine, posizioniamo nuovamente la stessa immagine a destra e la adattiamo sia all’altezza che alla larghezza del riquadro immagine, distorcendo l’immagine.

Ed ecco il risultato nel file XPS salvato: