Anpassa presentationsformer i C++

Översikt

Den här artikeln förklarar hur du anpassar presentationsformer i Aspose.Slides genom att redigera formgeometri via redigeringspunkter och geometriska banor. Den visar hur du arbetar med GeometryPath och IGeometryPath för att ändra befintliga former, utföra grundläggande redigeringsoperationer för banor, lägga till eller ta bort punkter och tillämpa uppdaterad geometri på en form.

Ändra en form med hjälp av redigeringspunkter

Tänk på en kvadrat. I PowerPoint, med redigeringspunkter, kan du

flytta kvadratens hörn inåt eller utåt
ange krökning för ett hörn eller en punkt
lägga till nya punkter till kvadraten
manipulera punkter på kvadraten osv.

I princip kan du utföra de beskrivna uppgifterna på vilken form som helst. Med redigeringspunkter kan du ändra en form eller skapa en ny form utifrån en befintlig form.

Tips för redigering av former

overview_image

Innan du börjar redigera PowerPoint‑former via redigeringspunkter kan du fundera på dessa aspekter av former:

En form (eller dess bana) kan antingen vara sluten eller öppen.
När en form är sluten saknar den en start‑ eller slutpunkt. När en form är öppen har den ett början och ett slut.
Alla former består av minst två ankarpunkter som är kopplade till varandra med linjer.
En linje är antingen rak eller kurvig. Ankarnpunkterna bestämmer linjens natur.
Ankarnpunkter finns som hörnpunkter, raka punkter eller jämna punkter:
- En hörnpunkt är en punkt där två raka linjer möts i en vinkel.
- En jämn punkt är en punkt där två handtag finns på en rak linje och linjesegmenten förenas i en mjuk kurva. I detta fall är alla handtag separerade från ankarnpunkten med lika stort avstånd.
- En rak punkt är en punkt där två handtag finns på en rak linje och linjesegmenten förenas i en mjuk kurva. I detta fall behöver handtagen inte vara lika långt från ankarnpunkten.
Genom att flytta eller redigera ankarnpunkter (vilket ändrar linjernas vinklar) kan du förändra hur en form ser ut.

För att redigera PowerPoint‑former via redigeringspunkter tillhandahåller Aspose.Slides klassen GeometryPath och gränssnittet IGeometryPath.

En GeometryPath-instans representerar en geometrisk bana för objektet IGeometryShape.
För att hämta GeometryPath från IGeometryShape‑instansen kan du använda metoden IGeometryShape::GetGeometryPaths.
För att ange GeometryPath för en form kan du använda dessa metoder: IGeometryShape::SetGeometryPath() för solida former och IGeometryShape::SetGeometryPaths() för komposita former.
För att lägga till segment kan du använda metoderna under IGeometryPath.
Genom att använda metoderna IGeometryPath::set_Stroke() och IGeometryPath::set_FillMode() kan du ange utseendet för en geometrisk bana.
Genom att använda metoden IGeometryPath::get_PathData() kan du hämta geometribanan för en GeometryShape som en array av bansegment.
För att komma åt ytterligare anpassningsalternativ för formgeometri kan du konvertera GeometryPath till GraphicsPath.
Använd metoderna GeometryPathToGraphicsPath och GraphicsPathToGeometryPath (från klassen ShapeUtil) för att konvertera GeometryPath till GraphicsPath och tillbaka.

Enkla redigeringsoperationer

Den här C++‑koden visar hur du

Lägg till en linje i slutet av en bana

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

Lägg till en linje på en specificerad position i en bana:

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

Lägg till en kubisk Bezier‑kurva i slutet av en bana:

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

Lägg till en kubisk Bezier‑kurva på den specificerade positionen i en bana:

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);

Lägg till en kvadratisk Bezier‑kurva i slutet av en bana:

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

Lägg till en kvadratisk Bezier‑kurva på en specificerad position i en bana:

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

Lägg till en given båge till en bana:

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

Stäng den aktuella figuren i en bana:

void CloseFigure();

Ange positionen för nästa punkt:

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

Ta bort bansegmentet vid ett givet index:

void RemoveAt(int32_t index);

Lägg till anpassade punkter till en form

Skapa en instans av klassen GeometryShape och ange typen ShapeType.Rectangle.
Hämta en instans av klassen GeometryPath från formen.
Lägg till en ny punkt mellan de två övre punkterna på banan.
Lägg till en ny punkt mellan de två nedre punkterna på banan.
Tillämpa banan på formen.

Den här C++‑koden visar hur du lägger till anpassade punkter till en form:

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

Ta bort punkter från en form

Skapa en instans av klassen GeometryShape och ange typen ShapeType.Heart.
Hämta en instans av klassen GeometryPath från formen.
Ta bort segmentet för banan.
Tillämpa banan på formen.

Den här C++‑koden visar hur du tar bort punkter från en form:

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

Skapa en anpassad form

Beräkna punkterna för formen.
Skapa en instans av klassen GeometryPath.
Fyll banan med punkterna.
Skapa en instans av klassen GeometryShape.
Tillämpa banan på formen.

Den här C++‑koden visar hur du skapar en anpassad form:

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

Skapa en sammansatt anpassad form

Skapa en instans av klassen GeometryShape.
Skapa en första instans av klassen GeometryPath.
Skapa en andra instans av klassen GeometryPath.
Tillämpa banorna på formen.

Den här C++‑koden visar hur du skapar en sammansatt anpassad form:

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

Skapa en anpassad form med krökta hörn

Den här C++‑koden visar hur du skapar en anpassad form med krökta hörn (inåtriktade);

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);

Ta reda på om en formgeometri är sluten

En sluten form definieras som en där alla sidor är sammankopplade och bildar en enda gräns utan luckor. En sådan form kan vara en enkel geometrisk form eller en komplex anpassad kontur. Följande kodexempel visar hur du kontrollerar om en formgeometri är sluten:

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;
}

Konvertera GeometryPath till GraphicsPath

Skapa en instans av klassen GeometryShape.
Skapa en instans av klassen GraphicsPath i namnområdet System.Drawing.Drawing2D.
Konvertera GraphicsPath-instansen till GeometryPath-instansen med hjälp av ShapeUtil.
Tillämpa banorna på formen.

Den här C++‑koden—en implementering av stegen ovan—demonstrerar konverteringsprocessen från GeometryPath till GraphicsPath:

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

Vanliga frågor

Vad händer med fyllning och kontur efter att geometrin ersatts?

Stilen förblir på formen; endast konturen ändras. Fyllning och kontur tillämpas automatiskt på den nya geometrin.

Hur roterar jag korrekt en anpassad form tillsammans med dess geometri?

Använd formens rotation‑egenskap; geometrin roterar med formen eftersom den är bunden till formens eget koordinatsystem.

Kan jag konvertera en anpassad form till en bild för att “låsa” resultatet?

Ja. Exportera det önskade slide-området eller själva shape till ett rasterformat; detta förenklar vidare arbete med tunga geometrier.

Hantera anslutare i presentationer med C++ Lägg till ellipser i presentationer i C++