Advanced Content Editor

Erstellt: 2026-05-27 · Aktualisiert: 2026-08-19

Der Advanced Content Editor ermöglicht es, PowerPoint-Shapes direkt mit C#-Code zu erstellen, zu testen und als Snippet in der Bibliothek zu speichern. Scripts werden mit Roslyn (Microsoft C# Scripting) zur Laufzeit ausgeführt.

Aufrufen

• Ribbon → Tools → Advanced Content Editor
• oder: in der Snippet- bzw. Action-Verwaltung über Code editieren — öffnet das Script des gewählten Eintrags direkt im Editor

Die Taskpane öffnet sich automatisch in der breiten Ansicht.

Interface

Toolbar

Die Toolbar ist in Schaltflächen-Gruppen organisiert. Schaltflächen mit einem kleinen Pfeil ▾ öffnen ein Dropdown mit Optionen.

Ausführen & Speichern

Dropdown «💾 Speichern»:

Analyse & Code

Dropdown «🔍 Analyse»:

Zeilennummern & Cursor-Position

Das schmale Panel links vom Code-Feld zeigt automatisch die Zeilennummern — synchron beim vertikalen Scrollen. Rechts in der Toolbar wird die aktuelle Cursor-Position angezeigt:

Ln 12  Col 5

Die Anzeige aktualisiert sich bei jeder Cursor-Bewegung.

Verfügbare Variablen

Im Script stehen folgende Variablen direkt zur Verfügung:

ppptools-Methoden (Übersicht)

→ Vollständige Referenz mit Parametern und Codebeispielen: PPPTools-Referenz

Wichtige Scripting-Regeln

Roslyn-Scripts laufen in einem speziellen Kontext. Folgende Regeln müssen eingehalten werden:

var / dynamic statt Shape

Der Typ Shape existiert in zwei Namespaces gleichzeitig (Microsoft.Office.Core und Microsoft.Office.Interop.PowerPoint) — das führt zu einem Compiler-Fehler.

// ❌ Fehler — ambiguous reference (wenn Shape-Typen gemischt verwendet werden)
Shape oRect = ppptools.AddRect(...);

// ✅ Korrekt
var oRect = ppptools.AddRect(...);

Enums ohne PowerPoint.-Vorsatz

Ein Script bekommt die Namensräume Microsoft.Office.Core, Microsoft.Office.Interop.PowerPoint, System, System.Drawing und System.Collections.Generic bereits importiert. Enums werden deshalb ohne Vorsatz geschrieben — PowerPoint. ist im Script kein Alias.

// ❌ Fehler CS0103: The name 'PowerPoint' does not exist in the current context
ppptools.SetText(sh, "Titel", align: PowerPoint.PpParagraphAlignment.ppAlignCenter);

// ✅ Korrekt
ppptools.SetText(sh, "Titel", align: PpParagraphAlignment.ppAlignCenter);

Dasselbe gilt für MsoTriState, MsoLineDashStyle und alle übrigen Office-Enums. Umgekehrt ist der Namensraum PPPTools nicht importiert: Wer einen Typ daraus ausschreibt — etwa FD_FillSpec — braucht using PPPTools; am Anfang des Scripts oder gleich var.

Lokale Funktion statt Action<T>

Action<Shape> scheitert am mehrdeutigen Typ Shape (siehe oben), nicht am Namensraum System — der ist importiert. Eine lokale Funktion mit dynamic umgeht die Mehrdeutigkeit:

// ❌ Fehler
Action<Shape> style = sh => { sh.Fill.ForeColor.RGB = ...; };

// ✅ Korrekt — lokale void-Funktion
void ApplyStyle(dynamic sh)
{
    sh.Fill.ForeColor.RGB = ...;
}

Selektion für Boolean-Operationen

List<Shape> ist wegen des Namespace-Konflikts nicht direkt verwendbar. Shapes werden stattdessen über .Select() selektiert:

// ✅ Korrekt
oShape1.Select(MsoTriState.msoTrue);   // erstes Shape: Replace = true
oShape2.Select(MsoTriState.msoFalse);  // weiteres Shape: Replace = false
ppptools.Union();
dynamic oResult = ppptools.GetSelected();   // Ergebnis-Shape abgreifen

Farben mit Design-Bezug setzen

Eine Farbe steht in einer PowerPoint-Datei auf eine von zwei Arten: als fester RGB-Wert oder als Verweis auf einen Farbplatz des Designs — „Akzent 1, 40 % heller“. Nur der Verweis folgt einem Vorlagenwechsel. Von Hand ist er unangenehm zu setzen, weil zwei Eigenschaften in der richtigen Reihenfolge dran müssen:

// Der Weg zu Fuss — und die Reihenfolge ist nicht beliebig:
// ObjectThemeColor setzt Brightness auf 0 zurück.
sh.Fill.ForeColor.ObjectThemeColor = MsoThemeColorIndex.msoThemeColorAccent1;
sh.Fill.ForeColor.Brightness       = 0.4f;

PPPTools bringt für genau das ein eigenes Farbmodell mit — dasselbe, das hinter den Format-Dialogen steckt. Ein Script kann es direkt benutzen: der Script-Host referenziert die PPPTools-Assembly.

Der kurze Weg

using PPPTools;   // nötig für die .ApplyTo(...)-Schreibweise

var farbe = FD_ColorValue.Parse("accent1+40");
farbe.ApplyTo(sh.Fill.ForeColor);
farbe.ApplyTo(sh.Line.ForeColor);

ApplyTo entscheidet selbst: Design-Bezug → ObjectThemeColor + Brightness in der richtigen Reihenfolge, feste Farbe → RGB, „Automatisch“ → das Ziel bleibt unangetastet. Der Rückgabewert sagt, ob etwas gesetzt wurde.

Was in den Text passt

Es sind dieselben Kürzel wie im Dateiformat (schemeClr val) und dieselben, die PPPTools in Vorlagen und Shape-Tags speichert. Parse wirft nie — Unlesbares ergibt auto.

Statt Text: direkt aufbauen

var a = FD_ColorValue.FromTheme(FD_ThemeSlot.Accent1, 0.4f, null);  // Bezug
var b = FD_ColorValue.FromHex("#8EAADB");                            // fest
var c = FD_ColorValue.FromRgb(System.Drawing.Color.Firebrick);       // fest
var d = FD_ColorValue.Auto;                                          // nicht gesetzt

Das null bei FromTheme ist die Designquelle. Fürs Setzen braucht es keine — der Farbplatz landet als Verweis in der Datei, PowerPoint rechnet ihn selbst aus. Gebraucht wird sie nur, wenn das Script die Farbe selbst kennen muss.

Die Farbe ausrechnen oder zurücklesen

var theme = FD_Theme.Snapshot();                 // frischer Abzug der Designfarben
System.Drawing.Color rgb = farbe.Resolve(theme); // was der Bezug im aktuellen Deck ergibt

var vorhanden = FD_ColorApply.Read(sh.Fill.ForeColor, theme);
if (vorhanden.HasThemeRef) { /* die Form folgt der Vorlage */ }

Die Regel: den Bezug speichern, nicht den ausgerechneten Wert

Resolve ist zum Anzeigen und Rechnen da, nicht zum Speichern. Wer die ausgerechnete Zahl in die Form schreibt, friert die Farbe ein — der nächste Vorlagenwechsel geht daran vorbei. Fest ist trotzdem richtig, wo die Farbe nicht folgen soll: Markenfarben, Pipettenfarben, Farben aus einem Bild.

Schrift, Rahmen und Füllung am Stück

Dieselbe Mechanik gibt es für ganze Formate. Jedes Feld ist optional — was null bleibt, wird nicht angefasst:

using PPPTools;
using System.Collections.Generic;

var theme = FD_Theme.Snapshot();

new FD_FontSpec { Family = "Segoe UI", Size = 18f, Bold = true,
                  Color = FD_ColorValue.Parse("accent2") }
    .ApplyToShape(sh, theme);

new FD_LineSpec { Visible = true, Weight = 1.5f, Dash = FD_LineDash.Dash,
                  Color = FD_ColorValue.Parse("dk1") }
    .ApplyToShape(sh, theme);

new FD_FillSpec
{
    Kind  = FD_FillKind.Gradient,
    Angle = 90f,
    Stops = new List<FD_GradientStop>
    {
        new FD_GradientStop(FD_ColorValue.Parse("accent1"),    0f),
        new FD_GradientStop(FD_ColorValue.Parse("accent1-30"), 1f)
    }
}.ApplyToShape(sh, theme);

Position und Transparenz eines Verlaufsstopps liegen als 0…1 vor, nicht in Prozent. ApplyToShape liefert zurück, wie viele Merkmale tatsächlich gesetzt wurden — 0 heisst „nichts angefordert“ oder „das Ziel kann nichts davon“.

Format-Dialoge aus dem Snippet heraus öffnen

Bis hierhin ging es um das Modell: Farben, Schriften, Rahmen und Füllungen, die als Werte im Script stehen. Ein Snippet kann die Format-Dialoge aber auch selbst öffnen und den Nutzer mitten im Lauf fragen — es sind dieselben Fenster, die auch das Menüband öffnet.

Der Unterschied zu den Snippet-Parametern: die werden vor dem Lauf abgefragt, es muss also schon vorher feststehen, wonach zu fragen ist. Mitten im Lauf geht auch, was sich erst beim Rechnen ergibt — pro gefundener Form, pro Gruppe, je nach Zwischenergebnis.

Alle Argumente sind freiwillig. Angewendet wird die Antwort mit ApplyColor, ApplyFont, ApplyLine und ApplyFill — die brauchen kein using PPPTools;.

Zum Ausprobieren: eine Form, vier Dialoge

Das Snippet erzeugt ein Rechteck und fragt nacheinander nach Füllung, Rahmen, Schrift und Textfarbe — einfügen, ausführen, fertig:

var sh = ppptools.AddRect(120, 120, 320, 140);
ppptools.SetText(sh, "Formatierte Testform",
    align: PpParagraphAlignment.ppAlignCenter);

var fuellung = ppptools.AskFill("Füllung der Testform", sh);   // Startwerte aus der Form
if (fuellung == null) return;                                  // null = abgebrochen
ppptools.ApplyFill(sh, fuellung);

var rahmen = ppptools.AskLine("Rahmen der Testform", sh);
if (rahmen != null) ppptools.ApplyLine(sh, rahmen);

var schrift = ppptools.AskFont("Schrift der Testform", sh);
if (schrift != null) ppptools.ApplyFont(sh, schrift);

var textfarbe = ppptools.AskColor("Textfarbe", "lt1");         // Vorschlag: Hintergrund 1
if (textfarbe != null) ppptools.ApplyColor(sh, textfarbe, "text");

ppptools.ShowResult("Fertig", "Testform formatiert.", "OK", "success");

Zum Vergleich dasselbe mit Parametern, also vor dem Lauf gefragt:

// @param font  Schrift   "Schrift"   default="Segoe UI,20,Bold"
// @param fill  Fuellung  "Füllung"   default="gradient:#0070C0,#00B0F0,90"
// @param line  Rahmen    "Rahmen"    default="#003A66,1.5,solid"
// @param color Textfarbe "Textfarbe" default="#FFFFFF"
// @button Testform erzeugen

var sh = ppptools.AddRect(120, 120, 320, 140);
ppptools.SetText(sh, "Formatierte Testform", color: Params.GetColor("Textfarbe"),
                 align: PpParagraphAlignment.ppAlignCenter);

ppptools.ApplyFill(sh, Params.GetFill("Fuellung"));   // FillSpec aus @param fill
ppptools.SetLine (sh, Params.GetLine("Rahmen"));      // LineSpec aus @param line
ppptools.SetFont (sh, Params.GetFont("Schrift"));     // Font aus @param font

Der Unterschied steckt nicht im Aufwand, sondern im Ergebnis: AskColor liefert die Farbe mit Design-Bezug zurück, @param color nur einen fertigen Farbwert.

Welche Variante wann?

Beides schliesst sich nicht aus: ein Snippet darf im Kopf @param-Zeilen führen und später nachfragen — etwa die Grundeinstellung vorab, die Ausnahme pro Form mitten im Lauf.

Fragen und anwenden

var farbe = ppptools.AskColor("Farbe für die Kopfzeile", "accent1+40");
if (farbe == null) return;                 // abgebrochen

ppptools.ApplyColor(sh, farbe);            // Füllung (Vorgabe)
ppptools.ApplyColor(sh, farbe, "line");    // Rahmen
ppptools.ApplyColor(sh, farbe, "text");    // Schriftfarbe

var schrift = ppptools.AskFont("Schrift", sh);   // Startwerte aus der Form
if (schrift != null) ppptools.ApplyFont(sh, schrift);

var rahmen = ppptools.AskLine("Rahmen", sh);
if (rahmen != null) ppptools.ApplyLine(sh, rahmen);

var fuellung = ppptools.AskFill("Füllung", sh);
if (fuellung != null) ppptools.ApplyFill(sh, fuellung);

ApplyFont, ApplyLine und ApplyFill liefern zurück, wie viele Merkmale gesetzt wurden.

Womit der Dialog aufgeht

start nimmt bei AskFont, AskLine und AskFill zweierlei: eine Form — dann liest der Dialog deren jetzige Werte als Startwerte — oder eine frühere Antwort, dann steht er wieder dort, wo der Nutzer ihn zuletzt verlassen hat. Bei AskColor ist start ein Speicherstring ("accent1+40", "#1F4E79", "auto").

Zusammen ergibt das die Schleife, die mit Parametern nicht auszudrücken war:

FD_FillSpec zuletzt = null;                 // braucht using PPPTools; — oder gleich var
foreach (dynamic sh in ppptools.GetSelectedRange())
{
    string name  = sh.Name;
    object start = (object)zuletzt ?? (object)sh;

    zuletzt = ppptools.AskFill("Füllung für " + name, start);
    if (zuletzt == null) break;             // Abbruch beendet die Schleife
    ppptools.ApplyFill(sh, zuletzt);
}

Nur ändern, was angehakt ist

Der dritte Schalter bei AskFont, AskLine und AskFill ist der Änderungsmodus: jedes einzelne Merkmal darf dann auf „unverändert" stehen bleiben. Gesetzt wird nur, was der Nutzer wirklich anhakt, der Rest der Form bleibt, wie er ist. Ohne den Schalter liefert der Dialog einen vollständigen Satz Werte.

var nur = ppptools.AskFont("Was soll sich ändern?", sh, true);
if (nur != null) ppptools.ApplyFont(sh, nur);

Bezug statt Wert

AskColor liefert einen FD_ColorValue, und ApplyColor schreibt den Design-Bezug als solchen auf die Form — die Farbe folgt danach einem Vorlagenwechsel. Genau das können die Parameter nicht: @param color reicht an der Parametergrenze nur noch einen fertigen Farbwert weiter.

Für die Methoden, die eine feste Farbe erwarten (SetFill, SetLine, SetGradient), löst ToColor den Bezug am Design des Foliensatzes auf:

var c = ppptools.AskColor("Farbe", "accent1");
if (c == null) return;

ppptools.ApplyColor(sh, c);                                   // behält „Akzent 1"
ppptools.SetGradient(sh2, ppptools.ToColor(c), Color.White);  // fester Wert

AskRgb ist dasselbe eine Stufe früher: Es fragt gleich nach einem festen Farbwert.

Beispiele

Jedes Beispiel hat eine eigene Seite mit Ergebnis-Vorschau, vollständigem Code und Schritt-für-Schritt-Erklärung.

Grundlagen-Beispiele (Boolean-Operationen):

Vollständige parametrisierte Beispiele (alle ppptools-Methoden):

Workflow

Code aus selektiertem Shape generieren

Die Optionen Code generieren (ersetzen) und Code generieren (anfügen) lesen das aktuell in PowerPoint selektierte Shape und erzeugen sofort ausführbaren ppptools.*-Code.

Ersetzen vs. Anfügen:

Was wird generiert:

Nodes anzeigen

Die Option Nodes anzeigen platziert farbige Markierungen direkt auf der Folie für jeden Knotenpunkt des selektierten Shapes.

FreeForm-Shapes

Bei FreeForm-Shapes wird jeder Knoten mit Koordinaten, Index, Segment-Typ (Line / Curve) und Editing-Typ (Corner / Auto) beschriftet.

Farb-Kodierung:

Standard-Shapes (Rechteck, Oval, AutoShape …)

Bei Standard-Shapes werden die 4 Eckpunkte (TL / TR / BR / BL) und der Mittelpunkt (C) angezeigt:

Darüber erscheint ein Info-Label mit Name, Typ und Abmessungen des Shapes.

Code analysieren

Die Option Code analysieren prüft das aktuelle Script statisch und zeigt das Ergebnis in einem Dialog:

• Erkannte @param-Definitionen (Name, Typ, Standardwert)
• Compiler-Warnungen
• Compiler-Fehler

Nützlich um zu prüfen, ob alle @param-Deklarationen korrekt sind, bevor das Script ausgeführt wird.

→ Mehr zu @param: Parametrisierte Snippets

Script testen

1. Code in das Code-Feld eingeben oder per 📂 Laden ein bestehendes Snippet öffnen
2. ▶ Ausführen klicken — das Shape erscheint auf der aktiven Folie
3. Bei Fehlern: Fehler-Panel lesen, Code korrigieren, erneut ausführen
4. Testweise erstellte Shapes manuell löschen (Entf-Taste)

Als Snippet speichern

1. 💾 Speichern ▾ → Als Snippet speichern klicken
2. Script wird ausgeführt — neu erstellte Shapes werden automatisch erkannt
3. Vorschaubild wird aus den neuen Shapes generiert
4. Shapes werden nach dem Vorschaubild-Export wieder gelöscht
5. Metadaten-Dialog: Name*, Kategorie, Tags, Beschreibung usw. eingeben
6. Speichern — Snippet erscheint sofort in der Galerie

Bestehendes Snippet bearbeiten

Ein bereits gespeichertes Code-Snippet öffnest du nicht über 📂 Laden, sondern direkt aus der Verwaltung:

1. Content Manager → Snippets → Verwalten, Snippet auswählen
2. Unter dem Vorschaubild auf Code editieren klicken

Der Editor öffnet sich im Snippet-Edit-Modus mit einer reduzierten Toolbar:

Als Draft zur öffentlichen Bibliothek hochladen

Fertige Snippets können direkt aus dem Editor als Entwurf (Draft) zur öffentlichen Bibliothek gesendet werden:

1. 💾 Speichern ▾ → Als Draft hochladen klicken
2. Script wird ausgeführt und ein Vorschaubild generiert
3. Metadaten-Dialog ausfüllen (Name*, Kategorie, Tags, Beschreibung)
4. Snippet wird als Draft an den Library-Server übertragen
5. Ein Admin prüft und veröffentlicht das Snippet

→ Publish-Flow

Microsoft-Dokumentation