Verwenden von XPS-Grafikdienstprogrammen | C++

So erstellen Sie einfach einfache Formen in XPS

Die XPS-Spezifikation definiert grafische Grundelemente, die zum Zusammenstellen komplexer Formen verwendet werden können. Aspose.Page für C++ stellt Klassen bereit, die diese Elemente kapseln. Allerdings kann ihre Verwendung etwas mühsam sein, wenn Sie selbst relativ einfache Formen erstellen müssen, wie etwa einen Kreissektor oder ein Segment oder ein regelmäßiges N-Eck, das in einen Kreis eingeschrieben oder darum herum umschrieben ist. Selbst das Zeichnen eines Kreises oder einer Ellipse ist nicht so einfach, wie es sein könnte und wahrscheinlich sein sollte. Aus diesem Grund bietet Aspose.Page zusätzlich eine Reihe von Hilfsmethoden, die Ihnen bei der Durchführung solcher Aufgaben höchstwahrscheinlich Zeit sparen werden.

Im folgenden Beispiel verwenden wir alle verfügbaren Formdienstprogramme. Beachten Sie, dass alle ein Objekt von XpsPathGeometry zurückgeben, das dann zum Erstellen von XPS-Pfaden verwendet werden kann. Und für diese Pfade können Sie Aussehenseigenschaften festlegen – Pinsel, Strichmuster, Deckkraft usw.

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

Wir beginnen mit einem neuen XPS-Dokument und passen dann die Größe der ersten Seite an. Die erste Form, die wir auf der Seite platzieren, ist ein Kreis (bestimmt durch Mittelpunkt und Radius), der mit durchgehendem Grün gefüllt ist. Als nächstes schreiben wir in diesen Kreis ein ungefülltes rotes regelmäßiges Fünfeck ein. Dann kommt ein umschriebenes regelmäßiges Sechseck, das mit Magenta gestrichen ist.

Rechts zeichnen wir zunächst einen roten kreisförmigen Sektor (oder ein „Kuchenstück“) zwischen -45 und +45 Grad und dann ein schwarzes kreisförmiges Segment mit denselben Parametern über dem Sektor.

Der letzte Teil der Zeichnung besteht aus einem roten Rechteck (bestimmt durch den oberen linken Scheitelpunkt und die Abmessungen) und einer gelben Ellipse (bestimmt durch den Mittelpunkt und die Radien), die in das Rechteck eingeschrieben sind. Hier kontrollieren wir die Beschriftung „von Hand“.

Folgendes sollten wir in der gespeicherten XPS-Datei sehen:

So fügen Sie einfach ein Bild auf einer XPS-Seite hinzu

Bei durch die XPS-Spezifikation definierten Grundelementen besteht das Hinzufügen eines Bildes zu einer Seite aus zwei Schritten:

• Hinzufügen eines rechteckigen Pfads, den Sie mit dem Bild füllen möchten;
• Festlegen eines Bildpinsels für den Pfad, wobei Sie ein Ansichtsfeld und ein Ansichtsfenster angeben müssen. Im Allgemeinen müssen Sie die Auflösung und die Größe Ihres Bildes in Pixeln kennen, um die beiden erstgenannten Parameter genau angeben zu können.

Aber glücklicherweise gibt es unter den XPS-Grafikdienstprogrammen der Aspose.Page-API für C++ eine praktische Methode, die (fast) die ganze Arbeit für Sie erledigt. Es bietet Ihnen auch verschiedene Anpassungsmodi. Schauen wir uns das folgende Beispiel an:

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

Auch hier beginnen wir mit einem neuen XPS-Dokument und passen die Größe der ersten Seite an. An dieser Stelle ist es erwähnenswert, dass Ihr Bild, wenn es als Pinsel verwendet wird, standardmäßig auf die gleiche Weise über den rechteckigen Bereich gekachelt wird, als ob es im Modus XpsTileMode.Tile verwendet würde. Im ersten Teil des Beispiels zeigen wir jedoch, wie man diese Kachelung verhindern kann.

Wir möchten also zunächst, dass das Bild bei (10, 10) erscheint und in die Breite des rechteckigen Kastens passt, der 200 Einheiten breit und 200 Einheiten hoch ist. Um das Ergebnis klarer zu sehen, zeichnen wir zunächst das Kästchen selbst. Als nächstes erstellen wir das Bild (beachten Sie, dass es sich tatsächlich um einen gefüllten Pfad handelt). Nachdem wir schließlich die Füllung des Pfads erhalten und in XpsImageBrush umgewandelt haben, setzen wir die Eigenschaft „TileMode“ auf „XpsTileMode.None“. Rechts platzieren wir dasselbe Bild und passen es an die Höhe des Bildfelds an. Beachten Sie die Fliesen.

Schließlich platzieren wir dasselbe Bild noch einmal rechts und passen es sowohl der Höhe als auch der Breite des Bildfelds an, wodurch das Bild verzerrt wird.

Und hier ist das Ergebnis in der gespeicherten XPS-Datei: