Formen in Präsentationen in C++ anpassen

Eine Form mit Bearbeitungspunkten ändern

Betrachten Sie ein Quadrat. In PowerPoint können Sie mit Bearbeitungspunkten

die Ecke des Quadrats nach innen oder außen verschieben
die Krümmung einer Ecke oder eines Punktes festlegen
neue Punkte zum Quadrat hinzufügen
Punkte auf dem Quadrat manipulieren usw.

Im Wesentlichen können Sie die beschriebenen Vorgänge an jeder Form ausführen. Mit Bearbeitungspunkten können Sie eine Form ändern oder aus einer bestehenden Form eine neue Form erstellen.

Tipps zur Formbearbeitung

overview_image

Bevor Sie beginnen, PowerPoint‑Formen über Bearbeitungspunkte zu bearbeiten, sollten Sie folgende Punkte zu Formen beachten:

Eine Form (oder ihr Pfad) kann entweder geschlossen oder geöffnet sein.
Wenn eine Form geschlossen ist, fehlt ein Anfangs‑ oder Endpunkt. Bei einer offenen Form gibt es einen Anfang und ein Ende.
Alle Formen bestehen aus mindestens 2 Ankerpunkten, die durch Linien miteinander verbunden sind.
Eine Linie ist gerade oder gekrümmt. Ankerpunkte bestimmen die Art der Linie.
Ankerpunkte existieren als Eckpunkte, gerade Punkte oder glatte Punkte:
- Ein Eckpunkt ist ein Punkt, an dem 2 gerade Linien in einem Winkel zusammenlaufen.
- Ein glatter Punkt ist ein Punkt, an dem 2 Handles in einer geraden Linie liegen und die Segmente der Linie in einer sanften Kurve zusammenlaufen. In diesem Fall sind alle Handles in gleichem Abstand vom Ankerpunkt getrennt.
- Ein gerader Punkt ist ein Punkt, an dem 2 Handles in einer geraden Linie liegen und die Segmente der Linie in einer sanften Kurve zusammenlaufen. In diesem Fall müssen die Handles nicht im gleichen Abstand vom Ankerpunkt getrennt sein.
Durch Verschieben oder Bearbeiten von Ankerpunkten (was den Winkel der Linien ändert) können Sie das Aussehen einer Form verändern.

Um PowerPoint‑Formen über Bearbeitungspunkte zu bearbeiten, stellt Aspose.Slides die Klasse GeometryPath und das Interface IGeometryPath bereit.

Eine GeometryPath-Instanz stellt den Geometrie‑Pfad des Objekts IGeometryShape dar.
Um den GeometryPath aus der IGeometryShape‑Instanz abzurufen, können Sie die Methode IGeometryShape::GetGeometryPaths verwenden.
Um den GeometryPath für eine Form festzulegen, können Sie diese Methoden nutzen: IGeometryShape::SetGeometryPath() für solide Formen und IGeometryShape::SetGeometryPaths() für komposite Formen.
Um Segmente hinzuzufügen, können Sie die Methoden unter IGeometryPath verwenden.
Mit den Methoden IGeometryPath::set_Stroke() und IGeometryPath::set_FillMode() können Sie das Aussehen eines Geometrie‑Pfads festlegen.
Mit der Methode IGeometryPath::get_PathData() können Sie den Geometrie‑Pfad eines GeometryShape als Array von Pfadsegmenten abrufen.
Um weitere Anpassungsoptionen für die Formgeometrie zu nutzen, können Sie GeometryPath in GraphicsPath konvertieren.
Verwenden Sie die Methoden GeometryPathToGraphicsPath und GraphicsPathToGeometryPath (aus der Klasse ShapeUtil), um GeometryPath in GraphicsPath und zurück zu konvertieren.

Einfache Bearbeitungsoperationen

Dieser C++‑Code zeigt, wie man

Eine Linie am Ende eines Pfades hinzufügt

void LineTo(PointF point);
void LineTo(float x, float y);

Eine Linie an einer angegebenen Position des Pfades hinzufügt:

void LineTo(PointF point, uint32_t index);
void LineTo(float x, float y, uint32_t index);

Eine kubische Bézier‑Kurve am Ende eines Pfades hinzufügt:

void CubicBezierTo(PointF point1, PointF point2, PointF point3);
void CubicBezierTo(float x1, float y1, float x2, float y2, float x3, float y3);

Eine kubische Bézier‑Kurve an einer angegebenen Position des Pfades hinzufügt:

void CubicBezierTo(PointF point1, PointF point2, PointF point3, uint32_t index);
void CubicBezierTo(float x1, float y1, float x2, float y2, float x3, float y3, uint32_t index);

Eine quadratische Bézier‑Kurve am Ende eines Pfades hinzufügt:

void QuadraticBezierTo(PointF point1, PointF point2);
void QuadraticBezierTo(float x1, float y1, float x2, float y2);

Eine quadratische Bézier‑Kurve an einer angegebenen Position des Pfades hinzufügt:

void QuadraticBezierTo(PointF point1, PointF point2, uint32_t index);
void QuadraticBezierTo(float x1, float y1, float x2, float y2, uint32_t index);

Einen angegebenen Bogen zu einem Pfad anhängt:

void ArcTo(float width, float heigth, float startAngle, float sweepAngle);

Die aktuelle Figur eines Pfades schließt:

void CloseFigure();

Die Position für den nächsten Punkt festlegt:

void MoveTo(PointF point);
void MoveTo(float x, float y);

Das Pfadsegment an einem angegebenen Index entfernt:

void RemoveAt(int32_t index);

Benutzerdefinierte Punkte zu einer Form hinzufügen

Erstellen Sie eine Instanz der Klasse GeometryShape und setzen Sie den Typ ShapeType.Rectangle.
Holen Sie sich eine Instanz der Klasse GeometryPath von der Form.
Fügen Sie einen neuen Punkt zwischen den beiden oberen Punkten des Pfades hinzu.
Fügen Sie einen neuen Punkt zwischen den beiden unteren Punkten des Pfades hinzu.
Wenden Sie den Pfad auf die Form an.

Dieser C++‑Code zeigt, wie man benutzerdefinierte Punkte zu einer Form hinzufügt:

SharedPtr<Presentation> pres = System::MakeObject<Presentation>();

SharedPtr<IShapeCollection> shapes = pres->get_Slides()->idx_get(0)->get_Shapes();
SharedPtr<GeometryShape> shape = System::ExplicitCast<GeometryShape>(shapes->AddAutoShape(ShapeType::Rectangle, 100.0f, 100.0f, 200.0f, 100.0f));

SharedPtr<IGeometryPath> geometryPath = shape->GetGeometryPaths()->idx_get(0);

geometryPath->LineTo(100.0f, 50.0f, 1);
geometryPath->LineTo(100.0f, 50.0f, 4);
shape->SetGeometryPath(geometryPath);

example1_image

Punkte aus einer Form entfernen

Erstellen Sie eine Instanz der Klasse GeometryShape und setzen Sie den Typ ShapeType.Heart.
Holen Sie sich eine Instanz der Klasse GeometryPath von der Form.
Entfernen Sie das Segment des Pfades.
Wenden Sie den Pfad auf die Form an.

Dieser C++‑Code zeigt, wie man Punkte aus einer Form entfernt:

SharedPtr<Presentation> pres = System::MakeObject<Presentation>();

SharedPtr<IShapeCollection> shapes = pres->get_Slides()->idx_get(0)->get_Shapes();
SharedPtr<GeometryShape> shape = System::ExplicitCast<GeometryShape>(shapes->AddAutoShape(ShapeType::Heart, 100.0f, 100.0f, 300.0f, 300.0f));

SharedPtr<IGeometryPath> path = shape->GetGeometryPaths()->idx_get(0);
path->RemoveAt(2);
shape->SetGeometryPath(path);

example2_image

Eine benutzerdefinierte Form erstellen

Berechnen Sie die Punkte für die Form.
Erstellen Sie eine Instanz der Klasse GeometryPath.
Füllen Sie den Pfad mit den Punkten.
Erstellen Sie eine Instanz der Klasse GeometryShape.
Wenden Sie den Pfad auf die Form an.

Dieser C++‑Code zeigt, wie man eine benutzerdefinierte Form erstellt:

SharedPtr<List<PointF>> points = System::MakeObject<List<PointF>>();

float R = 100.0f, r = 50.0f;
int32_t step = 72;

for (int32_t angle = -90; angle < 270; angle += step)
{
    double radians = angle * (Math::PI / 180.f);
    double x = outerRadius * Math::Cos(radians);
    double y = outerRadius * Math::Sin(radians);
    points->Add(PointF((float)x + outerRadius, (float)y + outerRadius));

    radians = Math::PI * (angle + step / 2) / 180.0;
    x = innerRadiusr * Math::Cos(radians);
    y = innerRadiusr * Math::Sin(radians);
    points->Add(PointF((float)x + outerRadius, (float)y + outerRadius));
}

SharedPtr<GeometryPath> starPath = System::MakeObject<GeometryPath>();
starPath->MoveTo(points->idx_get(0));

for (int32_t i = 1; i < points->get_Count(); i++)
{
    starPath->LineTo(points->idx_get(i));
}

starPath->CloseFigure();

SharedPtr<Presentation> pres = System::MakeObject<Presentation>();

SharedPtr<IShapeCollection> shapes = pres->get_Slides()->idx_get(0)->get_Shapes();
SharedPtr<GeometryShape> shape = System::ExplicitCast<GeometryShape>(shapes->AddAutoShape(ShapeType::Rectangle, 100.0f, 100.0f, R * 2, R * 2));

shape->SetGeometryPath(starPath);

example3_image

Eine zusammengesetzte benutzerdefinierte Form erstellen

Erstellen Sie eine Instanz der Klasse GeometryShape.
Erstellen Sie eine erste Instanz der Klasse GeometryPath.
Erstellen Sie eine zweite Instanz der Klasse GeometryPath.
Wenden Sie die Pfade auf die Form an.

Dieser C++‑Code zeigt, wie man eine zusammengesetzte benutzerdefinierte Form erstellt:

SharedPtr<Presentation> pres = System::MakeObject<Presentation>();

SharedPtr<IShapeCollection> shapes = pres->get_Slides()->idx_get(0)->get_Shapes();
SharedPtr<GeometryShape> shape = System::ExplicitCast<GeometryShape>(shapes->AddAutoShape(ShapeType::Rectangle, 100.0f, 100.0f, 200.0f, 100.0f));

SharedPtr<IGeometryPath> geometryPath0 = System::MakeObject<GeometryPath>();
geometryPath0->MoveTo(0.0f, 0.0f);
geometryPath0->LineTo(shape->get_Width(), 0.0f);
geometryPath0->LineTo(shape->get_Width(), shape->get_Height() / 3);
geometryPath0->LineTo(0.0f, shape->get_Height() / 3);
geometryPath0->CloseFigure();

SharedPtr<IGeometryPath> geometryPath1 = System::MakeObject<GeometryPath>();
geometryPath1->MoveTo(0.0f, shape->get_Height() / 3 * 2);
geometryPath1->LineTo(shape->get_Width(), shape->get_Height() / 3 * 2);
geometryPath1->LineTo(shape->get_Width(), shape->get_Height());
geometryPath1->LineTo(0.0f, shape->get_Height());
geometryPath1->CloseFigure();

shape->SetGeometryPaths(System::MakeArray<SharedPtr<IGeometryPath>>({ geometryPath0, geometryPath1 }));

example4_image

Eine benutzerdefinierte Form mit abgerundeten Ecken erstellen

Dieser C++‑Code zeigt, wie man eine benutzerdefinierte Form mit nach innen gerichteten abgerundeten Ecken erstellt:

float shapeX = 20.f;
float shapeY = 20.f;
float shapeWidth = 300.f;
float shapeHeight = 200.f;

float leftTopSize = 50.f;
float rightTopSize = 20.f;
float rightBottomSize = 40.f;
float leftBottomSize = 10.f;

auto presentation = System::MakeObject<Presentation>();

auto childShape = presentation->get_Slides()->idx_get(0)->get_Shapes()->AddAutoShape(ShapeType::Custom, shapeX, shapeY, shapeWidth, shapeHeight);

auto geometryPath = System::MakeObject<GeometryPath>();

PointF point1(leftTopSize, 0.0f);
PointF point2(shapeWidth - rightTopSize, 0.0f);
PointF point3(shapeWidth, shapeHeight - rightBottomSize);
PointF point4(leftBottomSize, shapeHeight);
PointF point5(0.0f, leftTopSize);

geometryPath->MoveTo(point1);
geometryPath->LineTo(point2);
geometryPath->ArcTo(rightTopSize, rightTopSize, 180.0f, -90.0f);
geometryPath->LineTo(point3);
geometryPath->ArcTo(rightBottomSize, rightBottomSize, -90.0f, -90.0f);
geometryPath->LineTo(point4);
geometryPath->ArcTo(leftBottomSize, leftBottomSize, 0.0f, -90.0f);
geometryPath->LineTo(point5);
geometryPath->ArcTo(leftTopSize, leftTopSize, 90.0f, -90.0f);

geometryPath->CloseFigure();

childShape->SetGeometryPath(geometryPath);

presentation->Save(u"output.pptx", SaveFormat::Pptx);

Herausfinden, ob eine Formgeometrie geschlossen ist

Eine geschlossene Form ist definiert als eine Form, bei der alle Seiten verbunden sind und eine einzige Grenze ohne Lücken bilden. Eine solche Form kann eine einfache geometrische Form oder ein komplexes benutzerdefiniertes Kontur sein. Das folgende Codebeispiel zeigt, wie man prüft, ob eine Formgeometrie geschlossen ist:

bool IsGeometryClosed(SharedPtr<IGeometryShape> geometryShape)
{
    bool isClosed = false;

    for (auto&& geometryPath : geometryShape->GetGeometryPaths())
    {
        auto dataLength = geometryPath->get_PathData()->get_Length();
        if (dataLength == 0)
            continue;

        auto lastSegment = geometryPath->get_PathData()[dataLength - 1];
        isClosed = lastSegment->get_PathCommand() == PathCommandType::Close;

        if (!isClosed)
            return false;
    }

    return isClosed;
}

GeometryPath in GraphicsPath konvertieren

Erstellen Sie eine Instanz der Klasse GeometryShape.
Erstellen Sie eine Instanz der Klasse GraphicsPath aus dem Namespace System.Drawing.Drawing2D.
Konvertieren Sie die GraphicsPath-Instanz in die GeometryPath-Instanz mithilfe von ShapeUtil.
Wenden Sie die Pfade auf die Form an.

Dieser C++‑Code – eine Implementierung der oben genannten Schritte – demonstriert den GeometryPath‑zu‑GraphicsPath‑Konvertierungsprozess:

SharedPtr<Presentation> pres = System::MakeObject<Presentation>();

SharedPtr<IShapeCollection> shapes = pres->get_Slides()->idx_get(0)->get_Shapes();
SharedPtr<GeometryShape> shape = System::ExplicitCast<GeometryShape>(shapes->AddAutoShape(ShapeType::Rectangle, 100.0f, 100.0f, 300.0f, 100.0f));

SharedPtr<IGeometryPath> originalPath = shape->GetGeometryPaths()->idx_get(0);
originalPath->set_FillMode(PathFillModeType::None);

SharedPtr<Drawing2D::GraphicsPath> graphicsPath = System::MakeObject<Drawing2D::GraphicsPath>();
graphicsPath->AddString(u"Text in shape", System::MakeObject<FontFamily>(u"Arial"), 1, 40.0f, PointF(10.0f, 10.0f), StringFormat::get_GenericDefault());

SharedPtr<IGeometryPath> textPath = ShapeUtil::GraphicsPathToGeometryPath(graphicsPath);
textPath->set_FillMode(PathFillModeType::Normal);

shape->SetGeometryPaths(System::MakeArray<SharedPtr<IGeometryPath>>({ originalPath, textPath }));

example5_image

FAQ

Was passiert mit Füllung und Kontur, nachdem die Geometrie ersetzt wurde?

Der Stil bleibt an der Form erhalten; nur die Kontur ändert sich. Füllung und Kontur werden automatisch auf die neue Geometrie angewendet.

Wie rotiere ich eine benutzerdefinierte Form korrekt zusammen mit ihrer Geometrie?

Verwenden Sie die Rotation‑Eigenschaft der Form; die Geometrie rotiert mit der Form, weil sie an das Koordinatensystem der Form gebunden ist.

Kann ich eine benutzerdefinierte Form in ein Bild konvertieren, um das Ergebnis „einzusperren“?

Ja. Exportieren Sie den gewünschten Foliensatz oder die Form selbst in ein Rasterformat; das vereinfacht die weitere Arbeit mit umfangreichen Geometrien.

Verbinder in Präsentationen mit C++ verwalten Ellipsen zu Präsentationen in C++ hinzufügen