Previous Next

Zeichnen

Geometrie

PDF verwendet die selbe Geometrie wie PostScript. Sie beginnt an der linken unteren Ecke der Seite und wird in Punkten (1/72 Zoll) gemessen.

Die Seitengröße kann vom Seitenobjekt erhalten werden:

$width  = $pdfPage->getWidth();
$height = $pdfPage->getHeight();

Farben

PDF bietet leistungsfähige Möglichkeiten für die Farbdarstellung. Die Zend_Pdf Komponente unterstützt die Grauskala sowie RGB und CYMK Farbräume. Jede kann überall verwendet werden, wo ein Zend_Pdf_Color Objekt benötigt wird. Die Zend_Pdf_Color_GrayScale, Zend_Pdf_Color_Rgb und Zend_Pdf_Color_Cmyk Klassen stellen folgende Funktionalitäten bereit:

// $grayLevel (Fließkommazahl). 0.0 (schwarz) - 1.0 (weiß)
$color1 = new Zend_Pdf_Color_GrayScale($grayLevel);

// $r, $g, $b (Fließkommazahlen). 0.0 (min Helligkeit) - 1.0 (max Helligkeit)
$color2 = new Zend_Pdf_Color_Rgb($r, $g, $b);

// $c, $m, $y, $k (Fließkommazahlen). 0.0 (min Helligkeit) - 1.0 (max Helligkeit)
$color3 = new Zend_Pdf_Color_Cmyk($c, $m, $y, $k);

HTML style colors are also provided with Zend_Pdf_Color_Html class:

$color1 = new Zend_Pdf_Color_Html('#3366FF');
$color2 = new Zend_Pdf_Color_Html('silver');
$color3 = new Zend_Pdf_Color_Html('forestgreen');

Zeichnen von Formen

Alle Zeichenoperationen können im Kontext einer PDF Seite durchgeführt werden.

Die Zend_Pdf_Page Klass stellt einen Satz von einfachen Formen bereit:

/**
 * Zeichne eine Linie von x1,y1 nach x2,y2.
 *
 * @param float $x1
 * @param float $y1
 * @param float $x2
 * @param float $y2
 */
public function drawLine($x1, $y1, $x2, $y2);
/**
 * Zeichne ein Rechteck.
 *
 * Füllarten:
 * Zend_Pdf_Page::SHAPE_DRAW_FILL_AND_STROKE - fülle und strichliere
 *                                             das Rechteck (Standard)
 * Zend_Pdf_Page::SHAPE_DRAW_STROKE          - strichele das Rechteck
 * Zend_Pdf_Page::SHAPE_DRAW_FILL            - fülle das Rechteck
 *
 * @param float $x1
 * @param float $y1
 * @param float $x2
 * @param float $y2
 * @param integer $fillType
 */
public function drawRectangle($x1, $y1, $x2, $y2,
                    $fillType = Zend_Pdf_Page::SHAPE_DRAW_FILL_AND_STROKE);
/**
 * Zeichne ein Polygon
 *
 * Wenn $fillType Zend_Pdf_Page::SHAPE_DRAW_FILL_AND_STROKE oder
 * Zend_Pdf_Page::SHAPE_DRAW_FILL ist, wird das Polygon automatisch geschlossen.
 * Für eine detaillierte Beschreibung dieser Methode schaue in eine PDF Dokumentation
 * (Kapitel 4.4.2 Path painting Operators, Filling)
 *
 * @param array $x  - Array mit Floats (die X Koordinaten der Eckpunkte)
 * @param array $y  - Array mit Floats (the Y Koordinaten der Eckpunkte)
 * @param integer $fillType
 * @param integer $fillMethod
 */
public function drawPolygon($x, $y,
                            $fillType =
                                Zend_Pdf_Page::SHAPE_DRAW_FILL_AND_STROKE,
                            $fillMethod =
                                Zend_Pdf_Page::FILL_METHOD_NON_ZERO_WINDING);
/**
 * Zeichne einen Kreis mit dem Mittelpunkt x, y dem Radius radius.
 *
 * Winkel werden im Bogenmaß angegeben
 *
 * Methoden Signaturen:
 * drawCircle($x, $y, $radius);
 * drawCircle($x, $y, $radius, $fillType);
 * drawCircle($x, $y, $radius, $startAngle, $endAngle);
 * drawCircle($x, $y, $radius, $startAngle, $endAngle, $fillType);
 *
 *
 * Es ist kein echter Kreis, weil PDF nur kubische Bezierkurven
 * unterstützt. Aber es ist eine sehr Annäherung.
 * Es unterscheidet sich von echten Kreisen maximal um 0.00026 Radien
 * (Bei PI/8, 3*PI/8, 5*PI/8, 7*PI/8, 9*PI/8, 11*PI/8, 13*PI/8 und
 * 15*PI/8 Winkeln). Bei 0, PI/4, PI/2, 3*PI/4, PI, 5*PI/4, 3*PI/2 und
 * 7*PI/4 ist es exakt eine Tangente zu einem Kreis.
 *
 * @param float $x
 * @param float $y
 * @param float $radius
 * @param mixed $param4
 * @param mixed $param5
 * @param mixed $param6
 */
public function  drawCircle($x,
                            $y,
                            $radius,
                            $param4 = null,
                            $param5 = null,
                            $param6 = null);
/**
 * Zeichne eine Ellipse innerhalb des angegebenen Rechtecks.
 *
 * Methoden Signaturen:
 * drawEllipse($x1, $y1, $x2, $y2);
 * drawEllipse($x1, $y1, $x2, $y2, $fillType);
 * drawEllipse($x1, $y1, $x2, $y2, $startAngle, $endAngle);
 * drawEllipse($x1, $y1, $x2, $y2, $startAngle, $endAngle, $fillType);
 *
 * Winkel werden im Bogenmaß angegeben
 *
 * @param float $x1
 * @param float $y1
 * @param float $x2
 * @param float $y2
 * @param mixed $param5
 * @param mixed $param6
 * @param mixed $param7
 */
public function drawEllipse($x1,
                            $y1,
                            $x2,
                            $y2,
                            $param5 = null,
                            $param6 = null,
                            $param7 = null);

Zeichnen von Text

Auch alle Textoperationen können im Kontext einer PDF Seite durchgeführt werden. Du kannst eine einzige Textzeile an jeder Position auf der Seite durch Übergabe der X und Y Koordinaten für die Grundlinie zeichnen. Der aktuelle Zeichensatz und die aktuelle Zeichengröße werden für die Textoperationen verwendet (beachte die detaillierte Beschreibung unten).

/**
 * Zeichne eine Textzeile an einer bestimmten Position.
 *
 * @param string $text
 * @param float $x
 * @param float $y
 * @param string $charEncoding (optional) Zeichencodierung des
 *               Quelltexts. Standard ist die aktuelle "locale".
 * @throws Zend_Pdf_Exception
 */
public function drawText($text, $x, $y, $charEncoding = '');

Example #1 Zeichne einen String auf der Seite

...
$pdfPage->drawText('Hello world!', 72, 720);
...

Standardmäßig werden Textstrings unter Verwendung der Zeichenkodierungsmethode der aktuelle "locale" interpretiert. Wenn du einen String hast, der eine andere Zeichenkodierungsmethode verwendet (wie zum Beispiel ein UTF-8 String, der aus einer Datei auf der Platte gelesen wurde, oder ein MacRoman String, der aus einer älteren Datenbank erhalten wurde), kannst du die Zeichenkodierung zum Zeitpunkt des Zeichnens angeben und Zend_Pdf wird die Konvertierung für dich durchführen. Du kannst Quellstrings in jeder Kodierungsmethode übergeben, die von PHP's » iconv() Funktion unterstützt wird.

Example #2 Zeiche einen UTF-8 kodierten String auf der Seite

...
// Lese einen UTF-8 kodierten String von der Platte
$unicodeString = fread($fp, 1024);

// Zeichne den String auf der Seite
$pdfPage->drawText($unicodeString, 72, 720, 'UTF-8');
...

Verwendung von Zeichensätzen

Zend_Pdf_Page::drawText() verwendet den aktuellen Zeichensatz und die aktuelle Zeichengröße der Seite, die mit der Methode Zend_Pdf_Page::setFont() festgelegt werden:

/**
 * Lege den aktuellen Zeichensatz fest.
 *
 * @param Zend_Pdf_Resource_Font $font
 * @param float $fontSize
 */
public function setFont(Zend_Pdf_Resource_Font $font, $fontSize);

PDF Dokumente unterstützt PostScript Type1 und TrueType Zeichensätze, sowie die zwei speziellen PDF Typen Type3 und zusammengesetzte Zeichensätze (composite fonts). Es gibt zudem 14 Type1 Standardzeichensätze, die von jedem PDF Viewer bereit gestellt werden: Courier (4 Stile), Helvetica (4 Stile), Times (4 Stile), Symbol und Zapf Dingbats.

Die Zend_Pdf Komponente unterstützt derzeit diese 14 Standardzeichensätze sowie deine eigenen TrueType Zeichensätze. Zeichensatzobjekte können über eine der zwei Fabrikmethoden (factory methods) erhalten werden: Zend_Pdf_Font::fontWithName($fontName) für die 14 PDF Standardzeichensätze oder Zend_Pdf_Font::fontWithPath($filePath) für eigene Zeichensätze.

Example #3 Erstelle einen Standardzeichensatz

...
// Erstelle einen neuen Zeichensatz
$font = Zend_Pdf_Font::fontWithName(Zend_Pdf_Font::FONT_HELVETICA);

// Wende Zeichensatz an
$pdfPage->setFont($font, 36);
...

Die Zeichensatzkonstanten für die 14 Standardzeichensätze sind innerhalb der Zend_Pdf_Font Klasse definiert:

  • Zend_Pdf_Font::FONT_COURIER

  • Zend_Pdf_Font::FONT_COURIER_BOLD

  • Zend_Pdf_Font::FONT_COURIER_ITALIC

  • Zend_Pdf_Font::FONT_COURIER_BOLDITALIC

  • Zend_Pdf_Font::FONT_TIMES_ROMAN

  • Zend_Pdf_Font::FONT_TIMES_BOLD

  • Zend_Pdf_Font::FONT_TIMES_ITALIC

  • Zend_Pdf_Font::FONT_TIMES_BOLDITALIC

  • Zend_Pdf_Font::FONT_HELVETICA

  • Zend_Pdf_Font::FONT_HELVETICA_BOLD

  • Zend_Pdf_Font::FONT_HELVETICA_ITALIC

  • Zend_Pdf_Font::FONT_HELVETICA_BOLDITALIC

  • Zend_Pdf_Font::FONT_SYMBOL

  • Zend_Pdf_Font::FONT_ZAPFDINGBATS

Du kannst außerdem jeden individuellen TrueType Zeichensatz (welcher normalerweise eine '.ttf' Erweiterung hat) oder einen OpenType Zeichensatz ('.otf' Erweiterung) verwenden, wenn er TrueType Konturen enthält. Bisher nicht unterstützt, aber für zukünftige Versionen geplant, sind Mac OS X .dfont Dateien und Microsoft TrueType Collection ('.ttc' Erweiterung) Dateien.

Um einen TrueType Zeichensatz zu verwenden, mußt du den kompletten Verzeichnispfad zum Zeichensatzprogramm angeben. Wenn der Zeichensatz aus welchem Grund auch immer nicht gelesen werden kann oder wenn es kein TrueType Zeichensatz ist, wird the Fabrikmethode eine Ausnahme werfen:

Example #4 Erstelle einen TrueType Zeichensatz

...
// Erstelle einen neuen Zeichensatz
$goodDogCoolFont = Zend_Pdf_Font::fontWithPath('/path/to/GOODDC__.TTF');

// Verwende den Zeichensatz
$pdfPage->setFont($goodDogCoolFont, 36);
...

Standardmäßig werden eigene Zeichensätze in das erstellte PDF Dokument eingebettet. Dies ermöglicht den Empfänger, die Seite wie beabsichtigt anzuschauen, sogar wenn sie den entsprechenden Zeichensatz auf ihrem System gar nicht installiert haben. Wenn du dich über die Dateigröße sorgst, kannst du angeben, dass das Zeichensatzprogramm nicht eingebettet wird, indem du eine 'nicht einbetten' Option an die Fabrikmethode übergibst:

Example #5 Erstelle einen TrueType Zeichensatz, aber bette ihn nicht in das PDF Dokument ein.

...
// Erstelle einen neuen Zeichensatz
$goodDogCoolFont = Zend_Pdf_Font::fontWithPath('/path/to/GOODDC__.TTF',
                                               Zend_Pdf_Font::EMBED_DONT_EMBED);

// Verwende den Zeichensatz
$pdfPage->setFont($goodDogCoolFont, 36);
...

Wenn das Zeichensatzprogramm nicht eingebettet wurde, aber den Empfänger der PDF Datei diesen Zeichensatz auf seinem System installiert hat, wird er das Dokument so sehen wie beabsichtigt. Wenn sie nicht den korrekten Zeichensatz installiert haben, wird der PDF Viewer sich bemühen, um einen Ersatz herzustellen.

Einige Zeichensätze haben sehr spezielle Lizensierungsregeln, die das Einbetten in PDF Dokumente verhindern. Damit du dadurch nicht überrascht wirst, wenn du versuchst einen Zeichensatz einzubetten, der nicht eingebettet werden kann, wird die Fabrikmethode eine Ausnahme werfen.

Du kannst diese Zeichensätze weiterhin verwenden, aber du mußt entweder die 'nicht einbetten' Option übergeben wie oben beschrieben oder du kannst einfach die Ausnahme unterdrücken:

Example #6 Werfe keine Ausnahme für Zeichensätze, die nicht eingebettet werden können.

...
$font = Zend_Pdf_Font::fontWithPath(
           '/path/to/unEmbeddableFont.ttf',
           Zend_Pdf_Font::EMBED_SUPPRESS_EMBED_EXCEPTION
        );
...

Diese Unterdrückungstechnik wird bevorzugt, wenn du einen Endnutzer erlaubst, seine eigenen Zeichensätze auszuwählen. Zeichensätze, die in ein PDF Dokument eingebettet werden können, werden eingebettet, andere nicht.

Zeichensatzprogramme können sehr groß sein, manche erreichen Dutzende von Megabytes. Standardmäßig werden alle eingebetteten Zeichensätze unter Verwendung des Flate Kompressionsschemas komprimiert, woraus im Schnitt 50% an Speicherplatz gespart werden kann. Wenn du aus welchem Grund auch immer nicht möchtest, dass das Zeichensatzprogramm kompimiert wird, kannst du dies mit einer Option abschalten:

Example #7 Komprimiere einen eingebetten Zeichensatz nicht.

...
$font = Zend_Pdf_Font::fontWithPath('/path/to/someReallyBigFont.ttf',
                                    Zend_Pdf_Font::EMBED_DONT_COMPRESS);
...

Zuguterletzt, kannst du die Einbettungsoptionen mit Hilfe des OR Operators kombinieren, wenn notwendig:

Example #8 Kombiniere die Zeichensatz Einbettungsoptionen.

...
$font = Zend_Pdf_Font::fontWithPath(
            $someUserSelectedFontPath,
            (Zend_Pdf_Font::EMBED_SUPPRESS_EMBED_EXCEPTION |
            Zend_Pdf_Font::EMBED_DONT_COMPRESS));
...

Beginnend mit 1.5, Schriften extrahieren

Das Zend_Pdf Modul bietet die Möglichkeit Schriften von geladenen Dokumenten zu extrahieren.

Das kann für aufsteigende Dokumenten Updates nützlich sein. Ohne diese Funktionalität müssen Schriften jedes Mal in ein Dokument hinzugefügt und möglicherweise eingebetten werden, wenn es aktualisiert werden soll.

Die Zend_Pdf und Zend_Pdf_Page Objekte bieten spezielle Methoden um alle genannten Schriften innerhalb eines Dokuments oder einer Seite zu extrahieren:

Example #9 Schriften von einem geladenen Dokument extrahieren

...
$pdf = Zend_Pdf::load($documentPath);
...
// Alle Schriften des Dokuments bekommen
$fontList = $pdf->extractFonts();
$pdf->pages[] = ($page = $pdf->newPage(Zend_Pdf_Page::SIZE_A4));
$yPosition = 700;
foreach ($fontList as $font) {
    $page->setFont($font, 15);
    $page->drawText(
       $font->getFontName(Zend_Pdf_Font::NAME_POSTSCRIPT, 'en', 'UTF-8') .
       ':  Der schnelle braune Fuchs springt über den lahmen Hund', 100, $yPosition, 'UTF-8');
    $yPosition -= 30;
}
...
// Alle Schriften die in der ersten Seite des Dokuments referenziert sind erhalten
$firstPage = reset($pdf->pages);
$firstPageFonts = $firstPage->extractFonts();
...

Example #10 Eine Schrift von einem geladenen Dokument extrahieren durch die Angabe des Schriftnamens

...
$pdf = new Zend_Pdf();
...
$pdf->pages[] = ($page = $pdf->newPage(Zend_Pdf_Page::SIZE_A4));

$font = Zend_Pdf_Font::fontWithPath($fontPath);
$page->setFont($font, $fontSize);
$page->drawText($text, $x, $y);
...
// Diese Schrift sollte woanders gespeichert werden...
$fontName = $font->getFontName(Zend_Pdf_Font::NAME_POSTSCRIPT,
                               'en',
                               'UTF-8');
...
$pdf->save($docPath);
...
...
$pdf = Zend_Pdf::load($docPath);
...
$pdf->pages[] = ($page = $pdf->newPage(Zend_Pdf_Page::SIZE_A4));

/* $srcPage->extractFont($fontName) kann auch hier verwendet werden */
$font = $pdf->extractFont($fontName);
$page->setFont($font, $fontSize);
$page->drawText($text, $x, $y);
...
$pdf->save($docPath, true /* aufsteigender Update Modus */);
...

Extrahierte Schriften können statt jeder anderen Schrift mit den folgenden Einschränkungen verwendet werden:

  • Eine extrahierte Schrift kann nur im Kontext des Dokuments verwendet werden von dem es extrahiert wurde.

  • Ein möglicherweise eingebettetes Schriftprogramm wird aktuell nicht extrahiert. Deswegen können extrahierte Schriften keine richtigen Schriftmaße bieten und die originale Schrift wird für die Berechnung der Breite verwendet:

    ...
    $font = $pdf->extractFont($fontName);
    $originalFont = Zend_Pdf_Font::fontWithPath($fontPath);
    
    $page->setFont($font /* Die extrahierte Schrift für das Zeichnen verwenden */, $fontSize);
    $xPosition = $x;
    for ($charIndex = 0; $charIndex < strlen($text); $charIndex++) {
        $page->drawText($text[$charIndex], xPosition, $y);
    
        // Die originale Schrift für die Berechnung der Breite des Textes verwenden
        $width += $originalFont->widthForGlyph(
                      $originalFont->glyphNumberForCharacter($text[$charIndex])
                  );
        $xPosition += $width/$originalFont->getUnitsPerEm()*$fontSize;
    }
    ...

Zeichnen von Grafiken

Die Zend_Pdf_Page Klasse stellt die drawImage() Methode für das Zeichnen von Grafiken bereit:

/**
 * Zeichne eine Grafik an der angegebenen Position der Seite.
 *
 * @param Zend_Pdf_Ressource_Image $image
 * @param float $x1
 * @param float $y1
 * @param float $x2
 * @param float $y2
 */
public function drawImage(Zend_Pdf_Ressource_Image $image, $x1, $y1, $x2, $y2);

Grafikobjekte sollten mit der Methode Zend_Pdf_Image::imageWithPath($filePath) erzeugt werden. (Es werden zur Zeit JPG, PNG und TIFF Grafiken unterstützt):

Example #11 Zeichnen von Grafiken

...
// Lade die Grafik
$image = Zend_Pdf_Image::imageWithPath('my_image.jpg');

$pdfPage->drawImage($image, 100, 100, 400, 300);
...

Wichtig! JPG Support setzt voraus, dass die GD Erweiterung für PHP konfiguriert wurde. Wichtig! PNG Support setzt voraus, dass die ZLIB Erweiterung konfiguriert wurde, um mit Grafiken mit Alphakanal zu arbeiten.

Wende dich an die PHP Dokumentation für weitere Informationen (» http://www.php.net/manual/de/ref.image.php). (» http://www.php.net/manual/de/ref.zlib.php).

Stil der Strichzeichnungen

Der Stil der Strichzeichnungen wurd durch die Linienbreite, die Linienfarbe und das Strichmuster definiert. Alle diese Parameter können an die Klassenmethoden von Zend_Pdf_Page übergeben werden:

/** Setze die Linienfarbe. */
public function setLineColor(Zend_Pdf_Color $color);

/** Setze die Linienbreite. */
public function setLineWidth(float $width);

/**
 * Setze das Strichmuster.
 *
 * Pattern ist ein Array mit Fließkommazahlen:
 *     array(on_length, off_length, on_length, off_length, ...)
 * Phase is shift from the beginning of line.
 *
 * @param array $pattern
 * @param array $phase
 */
public function setLineDashingPattern($pattern, $phase = 0);

Füllstil

Die Methoden Zend_Pdf_Page::drawRectangle(), Zend_Pdf_Page::drawPolygon(), Zend_Pdf_Page::drawCircle() und Zend_Pdf_Page::drawEllipse() akzeptieren das $fillType Argument als optionalen Parameter. Es kann lauten:

  • Zend_Pdf_Page::SHAPE_DRAW_STROKE - strichele die Form

  • Zend_Pdf_Page::SHAPE_DRAW_FILL - fülle die Form

  • Zend_Pdf_Page::SHAPE_DRAW_FILL_AND_STROKE - fülle und strichele die Form (Standardverhalten)

Die Zend_Pdf_Page::drawPolygon() Methode akzeptiert $fillMethod als zusätzlichen Parameter:

  • Zend_Pdf_Page::FILL_METHOD_NON_ZERO_WINDING (Standardverhalten)

    Die PDF Referenz beschreibt diese Regel wie folgt:

    The nonzero winding number rule determines whether a given point is inside a path by conceptually drawing a ray from that point to infinity in any direction and then examining the places where a segment of the path crosses the ray. Starting with a count of 0, the rule adds 1 each time a path segment crosses the ray from left to right and subtracts 1 each time a segment crosses from right to left. After counting all the crossings, if the result is 0 then the point is outside the path; otherwise it is inside. Note: The method just described does not specify what to do if a path segment coincides with or is tangent to the chosen ray. Since the direction of the ray is arbitrary, the rule simply chooses a ray that does not encounter such problem intersections. For simple convex paths, the nonzero winding number rule defines the inside and outside as one would intuitively expect. The more interesting cases are those involving complex or self-intersecting paths like the ones shown in Figure 4.10 (in a PDF Reference). For a path consisting of a five-pointed star, drawn with five connected straight line segments intersecting each other, the rule considers the inside to be the entire area enclosed by the star, including the pentagon in the center. For a path composed of two concentric circles, the areas enclosed by both circles are considered to be inside, provided that both are drawn in the same direction. If the circles are drawn in opposite directions, only the "doughnut" shape between them is inside, according to the rule; the "doughnut hole" is outside.

  • Zend_Pdf_Page::FILL_METHOD_EVEN_ODD

    Die PDF Referenz beschreibt diese Regel wie folgt:

    An alternative to the nonzero winding number rule is the even-odd rule. This rule determines the "insideness" of a point by drawing a ray from that point in any direction and simply counting the number of path segments that cross the ray, regardless of direction. If this number is odd, the point is inside; if even, the point is outside. This yields the same results as the nonzero winding number rule for paths with simple shapes, but produces different results for more complex shapes. Figure 4.11 (in a PDF Reference) shows the effects of applying the even-odd rule to complex paths. For the five-pointed star, the rule considers the triangular points to be inside the path, but not the pentagon in the center. For the two concentric circles, only the "doughnut" shape between the two circles is considered inside, regardless of the directions in which the circles are drawn.

Drehungen

Bevor eine Zeichenoperation angewendet wird, können PDF Seiten gedreht werden. Dies kann mit Hilfe der Zend_Pdf_Page::rotate() Methode durchgeführt werden:

/**
 * Drehe die Seite um den Punkt ($x, $y) mit dem angegebenen Winkel (im Bogenmaß).
 *
 * @param float $angle
 */
public function rotate($x, $y, $angle);

Speichern/Wiederherstellen des Grafikzustand

Jederzeit kann der Grafikzustand der Seite (aktueller Zeichensatz, Schriftgröße, Linienfarbe, Füllfarbe, Linienstil, Seitendrehung, Zeichenbereich) gespeichert und wiederhergestellt werden. Speicheroperationen legen die Daten auf einen Grafikzustand Stapel, Wiederherstelloperationen holen Sie daher zurück.

In der Zend_Pdf_Page Klasse gibt es für diese Operationen zwei Methoden:

/**
 * Speichere den Grafikzustand dieser Seite.
 * Es wir ein Schnappschuss vom aktuell festgelegten Stil, Position,
 * Zeichenbereich und jeder festgelegten Drehung/Umrechnung/Skalierung
 * erstellt.
 */
public function saveGS();

/**
 * Stelle den Grafikzustand wieder her, der mit dem letzten Aufruf von
 * saveGS() gespeichert wurde.
 */
public function restoreGS();

Zeichenbereich

PDF und die Zend_Pdf Komponente unterstützen die Begrenzung des Zeichenbereichs. Der aktuelle Zeichenbereich begrenzt den Seitenbereich, der von Zeichenoperationen beeinflusst werden kann. Zu Beginn ist dies die gesamte Seite.

Die Zend_Pdf_Page Klasse stellt einen Satz von Methoden für die Begrenzung bereit.

/**
 * Durchschneide den aktuellen Zeichenbereich mit einem Rechteck.
 *
 * @param float $x1
 * @param float $y1
 * @param float $x2
 * @param float $y2
 */
public function clipRectangle($x1, $y1, $x2, $y2);
/**
 * Durchschneide den aktuellen Zeichenbereich mit einem Polygon.
 *
 * @param array $x  - Array mit Floats (die X Koordinaten der Eckpunkte)
 * @param array $y  - Array mit Floats (die Y Koordinaten der Eckpunkte)
 * @param integer $fillMethod
 */
public function clipPolygon($x,
                            $y,
                            $fillMethod =
                                Zend_Pdf_Page::FILL_METHOD_NON_ZERO_WINDING);
/**
 * Durchschneide den aktuellen Zeichenbereich mit einem Kreis.
 *
 * @param float $x
 * @param float $y
 * @param float $radius
 * @param float $startAngle
 * @param float $endAngle
 */
public function clipCircle($x,
                           $y,
                           $radius,
                           $startAngle = null,
                           $endAngle = null);
/**
 * Durchschneide den aktuellen Zeichenbereich mit einer Ellipse.
 *
 * Methoden Signaturen:
 * drawEllipse($x1, $y1, $x2, $y2);
 * drawEllipse($x1, $y1, $x2, $y2, $startAngle, $endAngle);
 *
 * @todo verarbeite die Sonderfälle mit $x2-$x1 == 0 oder $y2-$y1 == 0
 *
 * @param float $x1
 * @param float $y1
 * @param float $x2
 * @param float $y2
 * @param float $startAngle
 * @param float $endAngle
 */
public function clipEllipse($x1,
                            $y1,
                            $x2,
                            $y2,
                            $startAngle = null,
                            $endAngle = null);

Stile

Die Zend_Pdf_Style Klasse stellt Stilfunktionalitäten bereit.

Stile können verwendet werden, um mit einer Operation die Parameter für den Grafikzustand zu speichern und auf eine PDF Seite anzuwenden:

/**
 * Lege den Stil für zukünftige Zeichenoperationen auf dieser Seite fest
 *
 * @param Zend_Pdf_Style $style
 */
public function setStyle(Zend_Pdf_Style $style);

/**
 * Gebe den Stil der Seite zurück.
 *
 * @return Zend_Pdf_Style|null
 */
public function getStyle();

Die Zend_Pdf_Style Klasse stellt einen Satz von Methoden bereit, um verschiedene Parameter des Grafikstadiums zu setzen und zu holen:

/**
 * Setze die Linienfarbe.
 *
 * @param Zend_Pdf_Color $color
 */
public function setLineColor(Zend_Pdf_Color $color);
/**
 * Hole die Linienfarbe.
 *
 * @return Zend_Pdf_Color|null
 */
public function getLineColor();
/**
 * Setze die Linienbreite.
 *
 * @param float $width
 */
public function setLineWidth($width);
/**
 * Hole die Linienbreite.
 *
 * @return float
 */
public function getLineWidth();
/**
 * Setze das Strichmuster
 *
 * @param array $pattern
 * @param float $phase
 */
public function setLineDashingPattern($pattern, $phase = 0);
/**
 * Hole das Strichmuster
 *
 * @return array
 */
public function getLineDashingPattern();
/**
 * Get line dashing phase
 *
 * @return float
 */
public function getLineDashingPhase();
/**
 * Setze die Füllfarbe
 *
 * @param Zend_Pdf_Color $color
 */
public function setFillColor(Zend_Pdf_Color $color);
/**
 * Hole die Füllfarbe.
 *
 * @return Zend_Pdf_Color|null
 */
public function getFillColor();
/**
 * Ändere den Zeichensatz.
 *
 * @param Zend_Pdf_Resource_Font $font
 * @param float $fontSize
 */
public function setFont(Zend_Pdf_Resource_Font $font, $fontSize);
/**
 * Ändere die Schriftgröße
 *
 * @param float $fontSize
 */
public function setFontSize($fontSize);
/**
 * Hole den Zeichensatz.
 *
 * @return Zend_Pdf_Resource_Font $font
 */
public function getFont();
/**
 * Hole die Schriftgröße
 *
 * @return float $fontSize
 */
public function getFontSize();

Transparenz

Das Zend_Pdf Modul unterstützt die Handhabung von Transparenz.

Transparenz kann durch Verwendung der Zend_Pdf_Page::setAlpha() Methode gesetzt werden:

/**
 * Setzt die Transparenz
 *
 * $alpha == 0  - Transparent
 * $alpha == 1  - Opaque
 *
 * Von PDF unterstützte Transparent-Modi:
 * Normal (standard), Multiply, Screen, Overlay, Darken, Lighten,
 * ColorDodge, ColorBurn, HardLight, SoftLight, Difference, Exclusion
 *
 * @param float $alpha
 * @param string $mode
 * @throws Zend_Pdf_Exception
 */
public function setAlpha($alpha, $mode = 'Normal');

Previous Next
Introduction to Zend Framework
Übersicht
Installation
Zend_Acl
Einführung
Verfeinern der Zugriffskontrolle
Fortgeschrittene Verwendung
Zend_Amf
Einführung
Zend_Amf_Server
Zend_Auth
Einführung
Datenbanktabellen Authentifizierung
Digest Authentication
HTTP Authentication Adapter
LDAP Authentifizierung
Open ID Authentifikation
Zend_Cache
Einführung
Die Theorie des Cachens
Zend_Cache Frontends
Zend_Cache Backends
Zend_Captcha
Einführung
Captcha Anwendung
Captcha Adapter
Zend_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Einführung in Getopt
Definieren von Getopt Regeln
Holen von Optionen und Argumenten
Konfigurieren von Zend_Console_Getopt
Zend_Controller
Zend_Controller Schnellstart
Zend_Controller Grundlagen
Der Front Controller
Das Request Objekt
Der Standard Router
Der Dispatcher
Action Kontroller
Action Helfer
Das Response Objekt
Plugins
Eine konventionelle modulare Verzeichnis Struktur verwenden
MVC Ausnahmen
Migration von vorhergehenden Versionen
Zend_Currency
Einführung in Zend_Currency
Arbeiten mit Währungen
Migration von vorhergehenden Versionen
Zend_Date
Einführung
Theorie der Arbeitsweise
Basis Methoden
Zend_Date API Übersicht
Erstellen von Datumswerten
Konstanten für generelle Datums Funktionen
Funktionierende Beispiele
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Zend_Db_Table Relationships
Zend_Debug
Variablen ausgeben
Zend_Dojo
Einführung
Zend_Dojo_Data: dojo.data Envelopes
Dojo View Helfer
Dojo Form Elemente und Dekoratore
Zend_Dom
Einführung
Zend_Dom_Query
Zend_Exception
Verwenden von Ausnahmen
Zend_Feed
Einführung
Feeds importieren
Feeds von Websites abrufen
Einen RSS Feed konsumieren
Einen Atom Feed konsumieren
Einen einzelnen Atom Eintrag konsumieren
Verändern der Feed- und Eintragsstruktur
Eigene Klassen für Feeds und Einträge
Zend_File
Zend_File_Transfer
Prüfungen für Zend_File_Transfer
Filter für Zend_File_Transfer
Migration von vorhergehenden Versionen
Zend_Filter
Einführung
Standard Filter Klassen
Filter Ketten
Filter schreiben
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Schnellstart mit Zend_Form
Erstellen von Form Elementen mit Hilfe von Zend_Form_Element
Erstellen von Form durch Verwendung von Zend_Form
Erstellen von eigenem Form Markup durch Zend_Form_Decorator
Standard Form Elemente die mit dem With Zend Framework ausgeliefert werden
Standard Form Dekoratore die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung zu Gdata
Authentifizierung mit AuthSub
Die Buchsuche Daten API verwenden
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Using Google Health
Google Tabellenkalkulation verwenden
Google Apps Provisionierung verwenden
Google Base verwenden
Picasa Web Alben verwenden
Verwenden der YouTube Daten API
Gdata Ausnahmen auffangen
Zend_Http
Zend_Http_Client - Einführung
Zend_Http_Client - Fortgeschrittende Nutzung
Zend_Http_Client - Verbindungsadapter
Zend_Http_Cookie und Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Einführung
Zend_Json
Einführung
Grundlegende Verwendung
JSON Objects
XML zu JSON Konvertierung
Zend_Json_Server - JSON-RPC server
Zend_Layout
Einführung
Zend_Layout Schnellstart
Zend_Layout Konfigurations Optionen
Erweiterte Verwendung von Zend_Layout
Zend_Ldap
Einleitung
Zend_Loader
Dynamisches Laden von Dateien und Klassen
Plugins laden
Zend_Locale
Einführung
Zend_Locale verwenden
Normalisierung und Lokalisierung
Arbeiten mit Daten und Zeiten
Unterstützte Gebietsschemata
Migrieren von vorhergehenden Versionen
Zend_Log
Übersicht
Writer
Formatter
Filter
Zend_Mail
Einführung
Versand über SMTP
Versand von mehreren E-Mails über eine SMTP Verbindung
Verwendung von unterschiedlichen Versandwegen
HTML E-Mail
Anhänge
Empfänger hinzufügen
Die MIME Abgrenzung kontrollieren
Zusätzliche Kopfzeilen
Zeichensätze
Kodierung
SMTP Authentifizierung
SMTP Übertragungen sichern
Lesen von Mail Nachrichten
Zend_Measure
Einführung
Erstellung einer Maßeinheit
Ausgabe von Maßeinheiten
Manipulation von Maßeinheiten
Arten von Maßeinheiten
Zend_Memory
Übersicht
Memory Manager
Memory Objekte
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_OpenId
Einführung
Zend_OpenId_Consumer Grundlagen
Zend_OpenId_Provider
Zend_Paginator
Einführung
Verwendung
Konfiguration
Advanced usage
Zend_Pdf
Einführung
Erstellen und Laden von PDF Dokumenten
Änderungen von PDF Dokumenten speichern
Dokument Seiten
Zeichnen
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_ProgressBar
Zend_ProgressBar
Zend_Registry
Die Registry verwenden
Zend_Rest
Einführung
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Überblick
Indexerstellung
Einen Index durchsuchen
Abfragesprache
Abfrage Erzeugungs API
Zeichensätze
Erweiterbarkeit
Zusammenarbeit Mit Java Lucene
Erweitert
Die besten Anwendungen
Zend_Server
Einführung
Zend_Server_Reflection
Zend_Service
Einführung
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_Flickr
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Einführung
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Mitgelieferte Services
Zend_Service_StrikeIron: Erweiterte Verwendung
Zend_Service_Technorati
Zend_Service_Twitter
Zend_Service_Yahoo
Zend_Session
Einführung
Grundsätzliche Verwendung
Fortgeschrittene Benutzung
Globales Session Management
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL Zugriffsmethoden
AutoDiscovery
Zend_Test
Einführung
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
Zend_Translate
Einführung
Adapter für Zend_Translate
Benutzen von Übersetzungs Adaptoren
Migration von vorhergehenden Versionen
Zend_Uri
Zend_Uri
Zend_Validate
Einführung
Standard Prüfklassen
Kettenprüfungen
Schreiben von Prüfern
Zend_Version
Auslesen der Version des Zend Frameworks
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Zend Framework Voraussetzungen
PHP Version
PHP Erweiterungen
Zend Framework Komponenten
Zend Framework Abhängigkeiten
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Zend Framework Performance Guide
Einführung
Laden von Klassen
Internationalisierung (I18n) und Lokalisierung (L10n)
Darstellen der View
Urheberrecht Informationen