Previous Next

Dojo View Helfer

Zend Framework bietet die folgenden Dojo-spezifischen View Helfer:

  • dojo(): Erstellt die Dojo Umgebung für die eigene Seite, inklusive der Werte für die Dojo Konfiguration, eigene Modulpfade, benötigte Modulstatements, Themenstylesheets, CDN Verwendung, und vieles mehr.

Example #1 Dojo View Helfer verwenden

Um die Dojo View Helfer zu verwenden muß man dem View Objekt mitteilen wo Sie zu finden sind. Das kann durch den Aufruf von addHelperPath() getan werden:

$view->addHelperPath('Zend/Dojo/View/Helper/', 'Zend_Dojo_View_Helper');

Alternativ kann Zend_Dojo's enableView() Methode verwendet werden um einem die Arbeit abzunehmen:

Zend_Dojo::enableView($view);

dojo() View Helfer

Der dojo() View Helfer ist dazu gedacht das konfigurieren der Dojo Umgebung zu vereinfachen, was die folgenden Notwendigkeiten beinhaltet:

  • Spezifizieren eines CDN oder lokalen Pfades zu einer Dojo Installation.

  • Spezifizieren von Pfaden zu eigenen Dojo Modulen.

  • Spezifizieren von dojo.require Statements.

  • Spezifizieren von Dijit Stylesheet Themen zur Verwendung.

  • Spezifizieren von dojo.addOnLoad() Events.

Die dojo() View Helfer Implementation ist ein Beispiel einer Platzhalter Implementation. Das Datenset in Ihm ist persistent zwischen den View Objekten, und kann direkt im eigenen Layout Skript ausgegeben werden.

Example #2 Beispiel für die Verwendung des dojo() View Helfers

Für dieses Beispiel nehmen wir an das der Entwickler Dojo von einem lokalen Pfad aus verwenden wird, verschiedene Dijits benötigt, und das Tundra Dijit Thema anpasst.

Auf vielen Seiten, kann der Entwickler Dojo nicht einmal verwenden. Deshalb werden wir uns zuerst auf ein View Skript fokusieren indem Dojo benötigt wird, und dann auf das Layout Skript, indem wir einiges der Dojo Umgebung einstellen und anschließend darstellen werden.

Zuerst müssen wir unserem View Objekt mitteilen das es die Dojo View Helferpfade verwenden soll. Das kann in der eigenen Bootstrap Datei getan werden oder in einem Plugin das früh abläuft; einfach das View Objekt nehmen und das folgende ausführen:

$view->addHelperPath('Zend/Dojo/View/Helper/', 'Zend_Dojo_View_Helper');

Als nächstes das View Skript. In diesem Fall werden die spezifizieren das ein FilterSelect verwendet werden soll -- welcher einen eigenen Speicher basierend auf QueryReadStore verwenden wird, und den wir 'PairedStore' nennen und in unserem 'custom' Modul speichern.


State: dojo()->enable() ->setDjConfigOption('parseOnLoad', true) ->registerModulePath('custom', '../custom/') ->requireModule('dijit.form.FilteringSelect') ->requireModule('custom.PairedStore'); ?>

In unserem Layout Skript, prüfen wir anschließend ob Dojo aktiviert ist, und wenn das der Fall ist, erledigen wir einige generelle Konfigurationen und fügen Sie hinzu:

doctype() ?>


    headTitle() ?>
    headMeta() ?>
    headLink() ?>
    headStyle() ?>
dojo()->isEnabled()){
    $this->dojo()->setLocalPath('/js/dojo/dojo.js')
                 ->addStyleSheetModule('dijit.themes.tundra');
    echo $this->dojo();
   }
?>
    headScript() ?>


    layout()->content ?>
    inlineScript() ?>

An diesem Punkt muß man nur sicherstellen das die Dateien am richtigen Ort vorhanden sind und das man die Aktion des Endpunktes für das FilteringSelect erstellt hat!

Programtechnische und Deklarative Verwendung von Dojo

Dojo erlaubt sowohl die deklarative als auch die programmtechnische Verwendung von vielen Ihrer Features. Deklarative Verwendung verwendet Standard HTML Elemente mit nicht-standard Attributen die geparst werden wenn die Seite geladen wird. Wärend das eine mächtige und einfach verwendbare Syntax ist, kann Sie für viele Entwickler Probleme bei der Überprüfung einer Seite verursachen.

Programmtechnische Verwendung erlaubt dem Entwickler existierende Elemente zu dekorieren indem Sie anhand von ID oder CSS Selektoren geholt werden und dem entsprechenden Objektkonstruktoren in Dojo übergeben werden. Weil keine nicht-standard HTML Attribute verwendet werden, bleiben Seiten hiermit gültig.

In der Praxis, erlauben beide Fälle eine zierliche Degeneration wenn Javascript ausgeschaltet ist, oder die verschiedenen Dojo Skriptresourcen nicht erreichbar sind. Um Standards und Dokumentüberprüfungen zu gestatten verwendet Zend Framework standardmäßig die programmtechnische Verwendung; die verschiedenen Viewhelfer erzeugen Javascript und übergeben dieses an den dojo() Viewhelfer für die Einbeziehung wenn er dargestellt wird.

Entwickler die diese Technik verwenden wollen eventuell auch die Option kennenlernen mit der Sie Ihre eigene programmtechnische Deklaration auf der Seite schreiben können. Ein Vorteil wäre die Möglichkeit Handler für Dijit Events zu spezifizieren.

Um das zu erlauben, wie auch die Möglichkeit die deklarative Syntax zu verwenden, sind es eine Anzahl von statischen Methoden vorhanden die dieses Verhalten global setzen.

Example #3 Spezifizieren der deklarativen und programmtechnischen Verwendung von Dojo

Um die deklarative Verwendung zu spezifizieren muß einfach die statische setUseDeclarative() Methode aufgerufen werden:

Zend_Dojo_View_Helper_Dojo::setUseDeclarative();

Wenn man stattdessen die programmtechnische Verwendung verwenden will, muß die statische setUseProgrammatic() Methode aufgerufen werden:

Zend_Dojo_View_Helper_Dojo::setUseProgrammatic();

Letztendlich, wenn man programmtechnische Regeln selbst erstellen will, sollte man die programmtechnische Verwendung spezifizieren, aber den Wert '-1' übergeben; in diesem Fall wird kein Javascript, für die Dekoration von verwendeten Dijits, erstellt.

Zend_Dojo_View_Helper_Dojo::setUseProgrammatic(-1);

Themen

Dojo erlaubt die Erstellung von Themen für seine Dijits (Widgets). Man kann eines auswählen indem ein Modulpfad übergeben wird:

$view->dojo()->addStylesheetModule('dijit.themes.tundra');

Der Modulpfad wird durch die Verwendung des Zeichens '.' als Trennzeichen vom Verzeichnis erkannt und der Verwendung des letzten Wertes in der Liste als den Namen der CSS Datei die im Themenverzeichnis verwendet wird; im obigen Beispiel sucht Dojo das Thema in 'dijit/themes/tundra/tundra.css'.

Wenn ein Thema verwendet wird ist es wichtig daran zu denken die Themenklasse, zumindest an den Container der jedes Dijit das verwendet wird umgibt, zu übergeben; im üblichsten Fällen wird es an den Body übergeben:



    

Layer verwenden (eigene Builds)

Wenn ein dojo.require Statement verwendet wird, wird Dojo standardmäßig eine Anfrage an den Server zurücksenden um die richtige Javascript Datei zu holen. Wenn man viele Dijits verwendet, resultiert das in vielen Anfragen an den Server -- was nicht optimal ist.

Dojo's Antwort darauf ist es die Möglichkeit anzubieten eigene Builds zu erstellen. Builds machen verschiedene Dinge:

  • Benötigte Dateien in Layern gruppieren; ein Layer sammelt alle benötigten Dateien in eine einzelne JS Datei. (Daher der Name dieses Kapitels)

  • "Interne" nicht-javascript Dateien die von Dijits verwendet werden (typischerweise Templatedateien). Diese werden auch in der gleichen JS Datei gruppiert wie der Layer.

  • Die Datei wird an ShrinkSafe übergeben, welches Leerzeichen und Kommentare entfernt, sowie Variablennamen verkleinert.

Einige Dateien können nicht in einen Layer gelegt werden, aber der Buildprozess wird ein spezielles Releaseverzeichnis mit der Layerdatei und allen anderen Dateien erstellen. Das erlaubt es eine verkleinerte eigene Distribution für die eigene Site oder Anwendungen zu erhalten.

Um einen Layer zu verwenden, hat der dojo() Viewhelfer eine addLayer() Methode für das hinzufügen von Pfaden zu benötigten Layern:

$view->dojo()->addLayer('/js/foo/foo.js');

Für weitere Informationen über die Erstellung von eigenen Build, schauen Sie bitte » in die Dojo Builddokumentation.

Vorhandene Methoden

Der dojo() Viewhelfer gibt immer eine Instanz des Dojo Platzhaltercontainers zurück. Dieses Containerobjekt bietet die folgenden Methoden an:

  • setView(Zend_View_Interface $view): Setzt eine Viewinstanz im Container

  • enable(): Die Dojo Integration explizit einschalten.

  • disable(): Die Dojo Integration ausschalten.

  • isEnabled(): Ermitteln ob die Dojo Integration eingeschaltet ist oder nicht.

  • requireModule($module): Ein dojo.require Statement konfigurieren.

  • getModules(): Erkennen welche Module benötigt werden.

  • registerModulePath($module, $path): Einen Dojo Modulpfad registrieren.

  • getModulePaths(): Eine Liste von registrierten Modulpfaden erhalten.

  • addLayer($path): Einen Layerpfad (eigenen Build) für die Verwendung hinzufügen.

  • getLayers(): Eine Liste von allen registrierten Layerpfaden (eigene Builds) erhalten.

  • removeLayer($path): Den Layer der $path entspricht von der Liste der registrierten Layer (eigene Builds) entfernen.

  • setCdnBase($url): Den Basis URL für ein CDN setzen; typischerweise ist das Zend_Dojo::CDN_BASE_AOL oder Zend_Dojo::CDN_BASE_GOOGLE, aber es wird der URL String vor der Versionsnummer benötigt.

  • getCdnBase(): Den Basis CDN URL empfangen.

  • setCdnVersion($version = null): Setzen selche Version von Dojo vom CDN verwendet wird.

  • getCdnVersion(): Die Dojo Version vom CDN erhalten die verwendet wird.

  • setCdnDojoPath($path): Setzt den relativen Pfad zur dojo.js oder dojo.xd.js Datei am CDN; typischerweise ist das entweder Zend_Dojo::CDN_DOJO_PATH_AOL oder Zend_Dojo::CDN_DOJO_PATH_GOOGLE, aber es wird der Pfadstring nach der Versionsnummer benötigt.

  • getCdnDojoPath(): Das letzte Pfadsegment der CDN URL erhalten das auf die dojo.js Datei zeigt.

  • useCdn(): Dem Container mitteilen das CDN verwendet werden soll; aktiviert die Integration implizit.

  • setLocalPath($path): Dem Container den Pfad zu einer lokalen Dojo Installation mitteilen (sollte ein Pfad relativ zum Server sein, und die dojo.js Datei selbst enthalten); aktiviert die Integration implizit.

  • getLocalPath(): Erkennen welches lokale Pfad zu Dojo verwendet wird.

  • useLocalPath(): Verwendet die Integration einen lokalen Dojopfad?

  • setDjConfig(array $config): Setzt Dojo/Dijit Konfigurationswerte (erwartet ein assoziatives Array).

  • setDjConfigOption($option, $value): Setzt einen einzelnen Dojo/Dijit Konfigurationswert.

  • getDjConfig(): Retourniert alle Dojo/Dijit Konfigurationswerte.

  • getDjConfigOption($option, $default = null): Retourniert einen einzelnen Dojo/Dijit Konfigurationswert.

  • addStylesheetModule($module): Fügt ein Stylesheet hinzu basierend auf einem Modulthema.

  • getStylesheetModules(): Retourniert die als Modulthema registrierten Modulthemen.

  • addStylesheet($path): Fügt einen lokalen Stylesheet zur Verwendung mit Dojo hinzu.

  • getStylesheets(): Retourniert die lokalen Dojo Stylesheets.

  • addOnLoad($spec, $function = null): Fügt ein Lambda für dojo.onLoad hinzu das dieses aufruft. Wenn ein Argument übergeben wird, wird dieses entweder als Funktionsname oder als Javascriptabschluss angenommen. Wenn zwei Argumente übergeben werden, wird das erste als Name der Variablen der Objektinstanz angenommen und der zweite entweder als Methodenname in diesem Objekt oder ein Abschluß um dieses Objekt zu verwenden.

  • prependOnLoad($spec, $function = null): genau wie addOnLoad(), außer das vor den Anfang des onLoad Stacks angefügt wird.

  • getOnLoadActions(): Gibt alle im Container registrierten dojo.onLoad Aktionen zurück. Das ist ein Array von Arrays.

  • onLoadCaptureStart($obj = null): Empfange Daten die als Lambda für dojo.onLoad() verwendet werden sollen. Wenn $obj angegeben wird, wird der bekommene JS Code als Abschluß angenommen der mit diesem Javascript Objekt verwendet werden soll.

  • onLoadCaptureEnd($obj = null): Beendet das Empfangen von Daten für die Verwendung mit dojo.onLoad().

  • javascriptCaptureStart(): Empfange Javascript das im Dojo JS inkludiert werden soll (onLoad, require, und andere Anweisungen).

  • javascriptCaptureEnd(): Beende das Empfangen von Javascript.

  • __toString(): Castet den Container zu einem String; stellt alle HTML Stile und Skriptelemente dar.

Dijit-Spezifische View Helfer

Aus dem Dojo Handbuch: "Dijit ist ein Widget System das über Dojo gelegt wurde.". Dijit enthält eine Vielzahl von Layout und Formular Widgets die erstellt wurden um Zugriffsfeatures, Lokalisation, und standardtisiertes (und themenbasierendes) Look-and-Feel zu bieten.

Zend Framework wird mit einer Vielzahl an View Helfern ausgeliefert die es erlauben Dijits in eigenen View Skripten darzustellen und anzupassen. Es gibt drei Basistypen:

  • Layout Container: Diese wurden erstellt um in View Skripten verwendet, oder von Formular Dekoratoren für Formulare, Unterformulare oder Anzeigegruppen konsumiert zu werden. Sie hüllen die verschiedenen angebotenen Klassen in dijit.layout ein. Jeder Dijit Layout Viewhelfer erwartet die folgenden Argumente:

    • $id: Der Name des Containers oder die DOM ID.

    • $content: Der Inhalt der vom Layout Container umhüllt werden soll.

    • $params (Optional): Dijit-spezifische Parameter. Grundsätzlich kann jedes nicht-HTML Attribut verwendet werden um den Dijit Layout Container zu konfigurieren.

    • $attribs (Optional): Jedes zusätzliche HTML Attribut das verwendet werden soll um den Container DIV darzustellen. Wenn der Schlüssel 'id' an dieses Array übergeben wird, wird es für die ID des DOM Formular Elements verwendet und $id wird für seinen Namen verwendet.

    Wenn an den Dijit Layout Viewhelfer keine Argumente übergeben werden, wird der Helfer selbst zurückgegeben. Das erlaubt es den Inhalt zu erhalten, was oft der einfachste Weg ist um Inhalt an den Layout Container zu übergeben. Beispiele für diese Funktionalität werden später in diesem Kapitel gezeigt.

  • Form Dijit: Auch wen das dijit.form.Form Dijit für die Verwendung von Dijit Form Elementen nicht vollständig notwendig ist, stellt es sicher das, wenn ein Versuch unternommen wird ein Formular zu übertragen das die Client-seitigen Prüfungen nicht besteht, die Übertragung angehalten und eine Prüffehlermeldung geworfen wird. Der Form Dijit Viewhelfer erwartet die folgenden Argumente:

    • $id: Der Name des Containers oder der DOM ID.

    • $attribs (Optional): Alle zusätzliche HTML Attribute die verwendet werden sollten um das Container DIV darzustellen.

    • $content (Optional): Der Inhalt der im Formular umschlossen wird. Wenn keiner übergeben wird, wird ein leerer String verwendet.

    Die Reihenfolge der Argumente variiert von den anderen Dijits um die Kompatibilität mit dem standard form() Viewhelfer zu haben.

  • Form Elemente: Diese wurden designed um von Zend_Form verwendet zu werden, können aber auch selbstständig in Viewsktipten verwendet werden. Jedes Dijit Element Viewhelfer erwartet die folgenden Elemente:

    • $id: Der Name des Elements oder die DOM ID.

    • $value (Optional): Der aktuelle Wert des Elements.

    • $params (Optional): Dijit-spezifische Parameter. Grundsätzlich können alle nicht-HTML Attribute für die Konfiguration des Dijits verwendet werden.

    • $attribs (Optional): Jedes zusätzliche HTML Attribut das verwendet werden soll um das Dijit darzustellen. Wenn der Schlüssel 'id' an dieses Array übergeben wird, wird es für die ID des DOM Formular Elements verwendet und $id wird für seinen Namen verwendet.

    Einige Elemente benötigen mehr Argumente; diese werden in den Beschreibungen der individuellen Elementhelfer erklärt.

Um diese Viewhelfer zu verwendenn, muß der Pfad zu den Dojo Viewhelfern im View Objekt registriert werden.

Example #4 Registrierung des Präfix Pfades zu den Dojo Viewhelfern

$view->addHelperPath('Zend/Dojo/View/Helper', 'Zend_Dojo_View_Helper');

Dijit Layout Elemente

Die Familie der dijit.layout Elemente sind für die Erstellung von eigenen, vorhersagbaren Layouts für die eigene Site. Für alle Fragen über die generelle Verwendung » lesen Sie hierüber im Dojo Handbuch nach.

Alle Dijit Layoutelemente haben die Signatur string ($id = null, $content = '', array $params = array(), array $attribs = array()). In allen Fällen wird, wenn man keine Argumente übergibt, das Helferobjekt selbst zurückgegeben. Das gibt einem Zugriff auf die captureStart() und captureEnd() Methoden, welche es erlauben Inhalte zu holen statt diese an den Layout Container zu übergeben.

  • AccordionContainer: dijit.layout.AccordionContainer. Fügt alle Ausschnitte vertikal zusallen; das Klicken auf die Überschrift eines Ausschnittes expandiert diesen und zeigt den betreffenden Ausschnitt an.

    accordionContainer(
        'foo',
        $content,
        array(
            'duration' => 200,
        ),
        array(
            'style' => 'width: 200px; height: 300px;',
        ),
    ); ?>
  • AccordionPane: dijit.layout.AccordionPane. Für die Verwendung im AccordionContainer.

    accordionPane(
        'foo',
        $content,
        array(
            'title' => 'Titel des Ausschnittes',
        ),
        array(
            'style' => 'background-color: lightgray;',
        ),
    ); ?>
  • BorderContainer: dijit.layout.BorderContainer. Ermöglicht Layouts mit optional größenveränderbaren Ausschnitten wie man Sie in traditionellen Anwendungen oft sieht.

    borderContainer(
        'foo',
        $content,
        array(
            'design' => 'headline',
        ),
        array(
            'style' => 'width: 100%; height: 100%',
        ),
    ); ?>
  • ContentPane: dijit.layout.ContentPane. Wird in allen Containern ausser AccordionContainer verwendet.

    contentPane(
        'foo',
        $content,
        array(
            'title'  => 'Titel des Ausschnittes',
            'region' => 'left',
        ),
        array(
            'style' => 'width: 120px; background-color: lightgray;',
        ),
    ); ?>
  • SplitContainer: dijit.layout.SplitContainer. Erlaubt Ausschnitte mit größenveränderbarem Inhalt; sollte in Dojo nicht mehr verwendet werden, stattdessen BorderContainer.

    splitContainer(
        'foo',
        $content,
        array(
            'orientation'  => 'horizontal',
            'sizerWidth'   => 7,
            'activeSizing' => true,
        ),
        array(
            'style' => 'width: 400px; height: 500px;',
        ),
    ); ?>
  • StackContainer: dijit.layout.StackContainer. Alle Ausschnitte eines StackContainers werden in einem Stack platziert; erstelle Buttons oder Funktionalität um einen auf einmal zu erhalten.

    stackContainer(
        'foo',
        $content,
        array(),
        array(
            'style' => 'width: 400px; height: 500px; border: 1px;',
        ),
    ); ?>
  • TabContainer: dijit.layout.TabContainer. Alle Ausschnitte eines TabContainers werden in einem Stack platziert, wobei Tabs auf einer Seite positioniert werden um zwischen Ihnen zu wählen.

    tabContainer(
        'foo',
        $content,
        array(),
        array(
            'style' => 'width: 400px; height: 500px; border: 1px;',
        ),
    ); ?>

Die folgenden Erfassungsmethoden sind für alle Layout Container vorhanden:

  • captureStart($id, array $params = array(), array $attribs = array()): Beginnt die Erfassung von Inhalt um Ihn in einem Container einzufügen. $params referiert auf die Dijit Parameters die mit dem Container verwendet werden, wärend $attribs auf alle generellen HTML Attribute die verwendet werden, zeigt.

    Container können für die Erfassung gekoppelt werden, solange keine IDs doppelt vorhanden sind.

  • captureEnd($id): Beendet die Erfassung von Inhalten die in den Container übernommen werden. $id sollte auf eine Id zeigen die vorher bei dem Aufruf von captureStart() verwendet wurde. Gibt einen String zurück der den Container und seinen Inhalt repräsentiert, wie wenn man einfach den Inhalt an den Helfer selbst übergeben hätte.

Example #5 Beispiel eines BorderContainer Layout Dijits

BorderContainers, speziell wenn Sie mit der Fähigkeit gekoppelt werden Inhalte zu erfassen, sind nützlich um komplexe Layouteffekte zu erhalten.

$view->borderContainer()->captureStart('masterLayout',
                                       array('design' => 'headline'));

echo $view->contentPane(
    'menuPane',
    'Das ist der Menü Ausschnitt',
    array('region' => 'top'),
    array('style' => 'background-color: darkblue;')
);

echo  $view->contentPane(
    'navPane',
    'Das ist der Navigations Ausschnitt',
    array('region' => 'left'),
    array('style' => 'width: 200px; background-color: lightblue;')
);

echo $view->contentPane(
    'mainPane',
    'Das ist der Hauptabschnitt',
    array('region' => 'center'),
    array('style' => 'background-color: white;')
);

echo $view->contentPane(
    'statusPane',
    'Status area',
    array('region' => 'bottom'),
    array('style' => 'background-color: lightgray;')
);

echo $view->borderContainer()->captureEnd('masterLayout');

Dijit Formularelemente

Dojo's Formularprüfung und Eingabe Dijits sind im dijit.form Baum. Für zusätzliche Informationen über die generelle Verwendung dieser Elemente, sowie der akzeptierten Parameter » besuchen Sie bitte die dijit.form Dokumentation.

Die folgenden Dijit Formularelemente sind im Zend Framework vorhanden. Ausser wo es beschrieben wird, haben alle die Signatur string ($id, $value = '', array $params = array(), array $attribs = array()).

  • Button: dijit.form.Button. Zeigt einen Formular Button.

    button(
        'foo',
        'Zeig mich!',
        array('iconClass' => 'myButtons'),
    ); ?>
  • CheckBox: dijit.form.CheckBox. Zeigt eine Checkbox an. Akzeptiert ein optionales fünftes Argument, das Array $checkedOptions, welches das folgende enthalten kann:

    • ein indiziertes Array mit zwei Werten, einen angehackten Wert und einem nicht angehackten Wert, in dieser Reihenfolge; oder

    • ein assoziatives Array mit den Schnüsseln 'checkedValue' und 'unCheckedValue'.

    Wenn $checkedOptions nicht vorhanden ist, wird 1 und 0 angenommen.

    checkBox(
        'foo',
        'bar',
        array(),
        array(),
        array('checkedValue' => 'foo', 'unCheckedValue' => 'bar')
    ); ?>
  • ComboBox: dijit.layout.ComboBox. Komboboxen sind ein Hybrid zwischen einem Select und einer Textbox mit automatischer Vervollständigung. Der grundsätzliche Unterschied ist das man eine Option eingeben kann die nicht in der Liste der vorhandenen Optionen ist, und trotzdem eine gültige Eingabe angenommen wird. Sie akzeptiert ein optionales fünftes Argument, ein assoziatives Array $options; wenn es angegeben wird, wird ComboBox als select dargestellt. Es ist auch zu beachten das die verschiedenen Labelwerte des $options Arrays im Formular zurückgegeben werden -- nicht die Werte selbst.

    Alternativ kann eine Information übergeben werden die einen dojo.data Datenspeicher bezeichnet der mit diesem Element zu verwenden ist. Wenn er angegeben wird, wird die ComboBox als Texteingabe (input) dargestellt, und wird seine Optionen über den Datenspeicher holen.

    Um einen Datenspeicher zu spezifizieren, muß eine der folgenden $params Schlüsselkombinationen angegeben werden:

    • Der Schlüssel 'store' mit einem Arraywert; das Array sollte die folgenden Schlüssel enthalten:

      • store: Der Name der Javascript Variable die den Datenspeicher repräsentiert (das könnte der Name sein den man für Ihn verwenden will).

      • type: Der Typ des Datenspeichers der verwendet werden soll; z.B., 'dojo.data.ItemFileReadStore'.

      • params (Optional): Ein assoziatives Array von Schlüssel/Werte Paaren die zu verwenden sind um den Datenspeicher zu konfigurieren. Der 'url' Parameter ist ein typisches Beispiel.

    • Die Schlüssel:

      • store: Ein String der den Namen des Datenspeicher zeigt der zu verwenden ist.

      • storeType: Ein String der den dojo.data.type des Datenspeichers anzeigt der zu verwenden ist (z.B. 'dojo.data.ItemFileReadStore').

      • storeParams: Ein assoziatives Array von Schlüssel/Wertepaaren mit denen der Datenspeicher konfiguriert wird.

    // Als Select Element:
    echo $view->comboBox(
        'foo',
        'bar',
        array(
            'autocomplete' => false,
        ),
        array(),
        array(
            'foo' => 'Foo',
            'bar' => 'Bar',
            'baz' => 'Baz',
        )
    );
    
    // Als dojo-aktiviertes Element:
    echo $view->comboBox(
        'foo',
        'bar',
        array(
            'autocomplete' => false,
            'store'        => 'stateStore',
            'storeType'    => 'dojo.data.ItemFileReadStore',
            'storeParams'  => array('url' => '/js/states.json'),
        ),
    );
  • CurrencyTextBox: dijit.form.CurrencyTextBox. Abgeleitet von ValidationTextBox, und bietet Clientseitige Prüfung von Wärgungen. Es erwartet das der Dijit Parameter 'currency' mit einem entsprechenden 3-zeichen Währungscode angegeben wird. Man kann auch anderen Dijit Parameter spezifizieren die für ValidationTextBox und TextBox gültig sind.

    echo $view->currencyTextBox(
        'foo',
        '$25.00',
        array('currency' => 'USD'),
        array('maxlength' => 20)
    );

    Note: Probleme mit Builds

    es gibt aktuell » bekannte Probleme bei der Verwendung der CurrencyTextBox mit Build Layern. Ein bekannter Work-Around ist sicherzustellen das das http-equiv Metatag des Content-Types des Dokument auf das Zeichenset utf-8 gestellt wird, was mit folgendem Aufruf gemacht wird:

    $view->headMeta()->appendHttpEquiv('Content-Type',
                                       'text/html; charset=utf-8');

    Das bedeutet natürlich, das man sicherstellen muß das der headMeta() Platzhalter im Layout Skript ausgegeben wird.

  • DateTextBox: dijit.form.DateTextBox. Wird von ValidationTextBox abgeleitet, und bietet sowohl Client-seitige Prüfungen von Daten, als auch einen Dropdown Kalender für die Auswahl von Daten. Man kann jeden Dijit Parameter spezifizieren der für ValidationTextBox oder TextBox vorhanden ist.

    echo $view->dateTextBox(
        'foo',
        '2008-07-11',
        array('required' => true)
    );
  • Editor: dijit.Editor. Bietet einen WYSIGYG Editor über den Benutzer Inhalte erstellen oder bearbieten können. dijit.Editor ist ein pluginfähiger, erweiterbarer Editor mit einer Vielzahl an Parametern die für die Anpassung verwendet werden können; siehe » in die dijit.Editor Dokumentation für weitere Details.

    echo $view->editor('foo');
  • FilteringSelect: dijit.form.FilteringSelect. Wie die ComboBox ist das ein Select/Text Hybrid der entweder eine angegebenen Liste von Optionen darstellen kann, oder jene vom dojo.data Datenspeicher. Anders als ComboBox, erlaubt FilteringSelect keine Eingabe einer Option die nicht in seiner Liste vorhanden ist. Zusätzlich funktioniert es Sie ein Standatrd Select in dem die Optionswerte, nicht die Label, zurückgegeben werden wenn das Formular übertragen wird.

    Bitte beachten Sie die obigen Informationen über die ComboBox für Beispiele und mögliche Optionen für die Definition von Datenspeichern.

  • HorizontalSlider und VerticalSlider: dijit.form.HorizontalSlider und dijit.form.VerticalSlider. Schieber sind UI Widgets für die Auswahl von Zahlen in einem gegebenen Bereich; es gibt eine horizontale und eine vertikale Variante.

    Grundsätzlich benötigen Sie die Dijit Parameter 'minimum', 'maximum' und 'discreteValues'. Diese definieren den Bereich der Werte. Andere übliche Optionen sind:

    • 'intermediateChanges' kann gesetzt werden um zu zeigen ob ein onChange Event ausgelöst wird wenn der Gleiter genommen wird.

    • 'clickSelect' kann gesetzt werden um das Klicken an einem Platz im Schieber zu erlauben um den Wert zu setzen.

    • 'pageIncrement' kann den Wert spezifizieren mit dem addiert/subtrahiert wird wenn pageUp und pageDown verwendet werden.

    • 'showButtons' kann gesetzt werden um die Darstellung von Buttons auf beiden Seiten des Schiebers, für die Veränderung des Wertes, zu erlauben.

    Die Zend Framework Implementation erstellt ein verstecktes Element um den Wert des Schiebers zu speichern.

    Optional kann es gewünscht sein einen Maßstab oder ein Label für den Gleiter zu zeigen. Um das zu tun, muß ein oder mehrere der Dijit Parameter 'topDecoration' und/oder 'bottomDecoration' (HorizontalSlider) oder 'leftDecoration' und/oder 'rightDecoration' (VerticalSlider) hinzufügen. Jede von Ihnen erwartet die folgenden Optionen:

    • container: Der Name des Containers.

    • labels (Optional): Ein Array von Labels das verwendet wird. Leere Strings können an beiden Seiten verwendet werden um Labels nur für die inneren Werte anzugeben. Wird benötigt wenn eine der 'Labels' Dijitvarianten spezifiziert wird.

    • dijit (Optional): Entweder HorizontalRule, HorizontalRuleLabels, VerticalRule, oder VerticalRuleLabels, standardmäßig einer der Rule Dijits.

    • params (optional): Dijit Parameter für die Konfiguration des Rule Dijits das verwendet wird. Spezifische Parameter für diese Dijits sind:

      • container (Optional): Ein Array von Parametern und Attributen für den Rule Container.

      • labels (Optional): Ein Array von Parametern und Attributen für die Labels des Containers.

    • attribs (Optional): HTML Attribute die mit den Maßstäben/Labels verwendet werden. Diese sollten dem Format der params Option folgen und können ein assoziatives Array mit den Schlüsseln 'container' und 'labels' sein.

    echo $view->horizontalSlider(
        'foo',
        1,
        array(
            'minimum'             => -10,
            'maximum'             => 10,
            'discreteValues'      => 11,
            'intermediateChanges' => true,
            'showButtons'         => true,
            'topDecoration'       => array(
                'container' => 'topContainer'
                'dijit'     => 'HorizontalRuleLabels',
                'labels'    => array(
                    ' ',
                    '20%',
                    '40%',
                    '60%',
                    '80%',
                    ' ',
                ),
                'params' => array(
                    'container' => array(
                        'style' => 'height:1.2em; font-size=75%;color:gray;',
                    ),
                    'labels' => array(
                        'style' => 'height:1em; font-size=75%;color:gray;',
                    ),
                ),
            ),
            'bottomDecoration'    => array(
                'container' => 'bottomContainer'
                'labels'    => array(
                    '0%',
                    '50%',
                    '100%',
                ),
                'params' => array(
                    'container' => array(
                        'style' => 'height:1.2em; font-size=75%;color:gray;',
                    ),
                    'labels' => array(
                        'style' => 'height:1em; font-size=75%;color:gray;',
                    ),
                ),
            ),
        )
    );
  • NumberSpinner: dijit.form.NumberSpinner. Eine Textbox für nummerische Eingaben mit Buttons für das Inkrementieren und Dekrementieren.

    Erwartet entweder ein Assoziatives Array für den Dijit Parameter 'constraints', oder einfach die Schlüssel 'min', 'max' und 'places' (das würden auch die erwarteten Einträge des Constraints Parameters sein). 'places' kann verwendet werden um anzugeben um wieviel der NumberSpinner erhöht oder erniedrigt wird.

    echo $view->numberSpinner(
        'foo',
        5,
        array(
            'min'    => -10,
            'max'    => 10,
            'places' => 2,
        ),
        array(
            'maxlenth' => 3,
        )
    );
  • NumberTextBox: dijit.form.NumberTextBox. NumberTextBox bietet die Möglichkeit die Nummerneinträge auf lokalisiertem Weg zu formatieren und anzuzeigen, optional gegen angegebene Abhängigkeiten.

    echo $view->numberTextBox(
        'foo',
        5,
        array(
            'places' => 4,
            'type'   => 'percent',
        ),
        array(
            'maxlength' => 20,
        )
    );
  • PasswordTextBox: dijit.form.ValidationTextBox bindet eine Passworteingabe. PasswordTextBox bietet die Möglichkeit Passworteingaben zu erstellen die das aktuelle Dijitthema verwenden, sowie Clientseitige Prüfungen erlauben.

    echo $view->passwordTextBox(
        'foo',
        '',
        array(
            'required' => true,
        ),
        array(
            'maxlength' => 20,
        )
    );
  • RadioButton: dijit.form.RadioButton. Ein Set von Optionen von denen nur eine ausgewählt werden kann. Dieses Verhalten entspricht auf jedem Fall dem normaler Radio Buttons, hat aber das Look-and-Feel das mit dem anderer Dijit konsistent ist.

    RadioButton akzeptiert ein optionales viertes Argument, $options, ein assoziatives Array von Werte/Label Paaren das als Radiooptionen verwendet wird. Diese können auch als $attribs Schlüssel Optionen angegeben werden.

    echo $view->radioButton(
        'foo',
        'bar',
        array(),
        array(),
        array(
            'foo' => 'Foo',
            'bar' => 'Bar',
            'baz' => 'Baz',
        )
    );
  • SimpleTextarea: dijit.form.SimpleTextarea. Diese funktionieren wie normale Textareas, werden aber gestylt indem das aktuelle dijit Thema verwendet wird. Es müssen weder die rows noch die columns Attribute spezifiziert werden; verwende stattdessen ems oder Prozente für die Breite und Höhe.

    echo $view->simpleTextarea(
        'foo',
        'Bitte ab hier schreiben...',
        array(),
        array('style' => 'width: 90%; height: 5ems;')
    );
  • SubmitButton: Ein dijit.form.Button bindet ein Submit Eingabeelement. Siehe den Button Viewhelfer für weitere Details; der grundsätzliche Unterschied ist der, das dieser Button ein Formular übertragen kann.

  • Textarea: dijit.form.Textarea. Diese funktionieren wie normale Textareas, ausgenommen das Sie statt dem Setzen einer Anzahl von Reihen als Benutzertypen expandieren. Die Breite sollte über Styleeinstellungen spezifiziert werden.

    echo $view->textarea(
        'foo',
        'Start writing here...',
        array(),
        array('style' => 'width: 300px;')
    );
  • TextBox: dijit.form.TextBox. Diese Element ist primär vorhanden um das übliche Look-and-Feel zwischen den verschiedenen Dijit Elementen zu bieten, und um die Basisfunktionalität der anderen von TextBox abgeleiteten Klassen (ValidationTextBox, NumberTextBox, CurrencyTextBox, DateTextBox, und TimeTextBox) zu bieten.

    Übliche Dijitparameter enthalten 'lowercase' (Casten auf kleinschreibung), 'uppercase' (Casten auf GROßSCHREIBUNG), 'propercase' (Casten auf ProperCase), und 'trim' (entferne führende und schließende Leerezeichen); alle akzeptieren boolsche Werte. Zusätzlich kann es gewünscht sein die Parameter 'size' und 'maxLength' zu spezifizieren.

    echo $view->textBox(
        'foo',
        'Irgendein Text',
        array(
            'trim'       => true,
            'propercase' => true,
            'maxLength'  => 20,
        ),
        array(
            'size' => 20,
        )
    );
  • TimeTextBox: dijit.form.TimeTextBox. Auch aus der TextBox Familie, bietet TimeTextBox eine Drop Down Auswahl für Zeiten die verschiebbar ist und die vom Benutzer ausgewählt werden kann. Dijit Parameter erlaubes es die Zeit zu spezifizieren die im Select vorhanden ist sowie auch den sichtbaren Bereich der Zeiten.

    echo $view->timeTextBox(
        'foo',
        '',
        array(
            'am.pm'            => true,
            'visibleIncrement' => 'T00:05:00', // 5-Minuten addieren
            'visibleRange'     => 'T02:00:00', // Zeigt 2 Stunden die hinzugefügt werden können
        ),
        array(
            'size' => 20,
        )
    );
  • ValidationTextBox: dijit.form.ValidateTextBox. Bietet Client-seitige Prüfungen für Textelemente. Ist von TextBox abgeleitet.

    Übliche Dijit Parameter enthalten:

    • invalidMessage: Eine Nachricht die angezeigt wird wenn eine ungültige Eingabe erkannt wurde.

    • promptMessage: Eine Tooltip Hilfenachricht die verwendet wird.

    • regExp: Ein regulärer Ausdruck der für die Prüfung des Textes verwendet wird. Reguläre Ausdrücke benötigen keine Begrenzungen.

    • required: Ob das Element benötigt wird oder nicht. Wenn das der Fall ist, und das Element in einem dijit.form.Form eingebettet ist, wird es als ungültig markiert und die Übertragung verhindert.

    echo $view->validationTextBox(
        'foo',
        '',
        array(
            'required' => true,
            'regExp'   => '[\w]+',
            'invalidMessage' => 'Keine Leerzeichen oder nicht-Wort Zeichen erlaubt',
            'promptMessage'  => 'Nur ein einzelnes Wort das aus ' .
                                'alphanummerischen Zeichen und Unterstrichen besteht',
        ),
        array(
            'maxlength' => 20,
        )
    );

Eigene Dijits

Wenn man viel in Dojo herumtaucht, wird man sehr bald selbst eigene Dijits schreiben, oder experimentelle Dijits von Dojox verwenden. Wärend Zend Framework nicht jeden Dijit direkt unterstützen kann, bietet es einiges an direkter rudimentärer Unterstützung für jeden Dijit, und es bietet einiges an rudimentärer Unterstützung für beliebige Dijit Typen über den CustomDijit View Helfer.

Die API des CustomDijit View Helfers ist genauso wie die jedes anderen Dijits, mit einem grundsätzlichen Unterschied: Das dritten "params" Argument muss das Attribut "dojotype" enthalten. Der Wert dieses Attributs sollte die Dijit Klasse sein die man verwenden will.

CustomDijit erweitert den Basis DijitContainer View Helfer, welches er erlaubt Inhalte zu fangen (durch Verwendung der captureStart()/captureEnd() Methodenpaare). captureStart() erwartet auch das man das "dojoType" Attribut als sein "params" Argument übergibt.

Example #6 Verwendung von CustomDijit um ein dojox.layout.ContentPane darzustellen

dojox.layout.ContentPane ist eine Next-Generation Erweiterung von dijit.layout.ContentPane und bietet ein Superset der Möglichkeiten dieser Klasse. Bis seine Funktionalitäten stabil sind, wird es weiterhin in Dojox leben. Wenn man es trotzdem im heutigen Zend Framework verwenden will, kann man den CustomDijit View Helfer verwenden. is a next-generation iteration of dijit.layout.ContentPane, and provides a superset of that class's capabilities. Until it's functionality stabilizes, it will continue to live in Dojox. However, if you want to use it in Zend Framework today, you can, using the CustomDijit view helper.

Grundsätzlich kann man das folgende tun:

customDijit(
    'foo',
    $content,
    array(
        'dojoType' => 'dojox.layout.ContentPane',
        'title'    => 'Eigene Ebene',
        'region'   => 'center'
    )
); ?>

Wenn man stattdessen Inhalte fangen will, sollte einfach die captureStart() Methode verwendet, und der "dojoType" als "params" Argument übergeben werden:

customDijit()->captureStart(
    'foo',
    array(
        'dojoType' => 'dojox.layout.ContentPane',
        'title'    => 'Eigene Ebene',
        'region'   => 'center'
    )
); ?>
Das ist der Inhalt der Ebene
customDijit()->captureEnd('foo'); ?>

Man kann CustomDijit auch einfach erweitern um Unterstützung für eigene Dijits zu bieten. Wenn man, als Beispiel, dijit.layout.ContentPane erweitern will um eine eigene foo.ContentPane Klasse zu erstellen, kann man den folgenden Helfer erstellen um Ihn zu unterstützen:

class My_View_Helper_FooContentPane
    extends Zend_Dojo_View_Helper_CustomDijit
{
    protected $_defaultDojoType = 'foo.ContentPane';

    public function fooContentPane(
        $id = null, $value = null,
        array $params = array(), array $attribs = array()
    ) {
        return $this->customDijit($id, $value, $params, $attribs);
    }
}

Solange der eigene Dijit der gleichen grundsätzlichen API wie offizielle Dijits folgt, sollte die Verwendung oder Erweiterung von CustomDijit korrekt funktionieren.

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_Application
Einführung
Zend_Application Quick Start
Theorie der Funktionsweise
Beispiele
Kern Funktionalität
Vorhandene Ressource Plugins
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_CodeGenerator
Einführung
Zend_CodeGenerator Beispiele
Zend_CodeGenerator Referenz
Zend_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Einführung
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
Formular Elemente und Dekoratore für Dojo
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 Formular Dekoratoren die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung
Authentifizierung mit AuthSub
Die Buchsuche Daten API verwenden
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Verwenden von 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
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
Fortgeschrittene Verwendung von Zend_Json
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
Der Autoloader
Ressource Autoloader
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_Navigation
Einführung
Seiten
Container
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 an PDF Dokumenten speichern
Arbeiten mit Seiten
Zeichnen
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_ProgressBar
Zend_ProgressBar
Zend_Reflection
Einführung
Zend_Reflection Beispiele
Zend_Reflection Referenz
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_Amazon_Ec2
Zend_Service_Amazon_Ec2: Instanzen
Zend_Service_Amazon_Ec2: Windows Instances
Zend_Service_Amazon_Ec2: Reserved Instances
Zend_Service_Amazon_Ec2: CloudWatch Monitoring
Zend_Service_Amazon_Ec2: Amazon Maschinen Images (AMI)
Zend_Service_Amazon_Ec2: Elastischer Block Speicher (EBS)
Zend_Service_Amazon_Ec2: Elastische IP Adressen
Zend_Service_Amazon_Ec2: Schlüsselpaare
Zend_Service_Amazon_Ec2: Regionen und Availability Zones
Zend_Service_Amazon_Ec2: Sicherheitsgruppen
Zend_Service_Amazon_S3
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_Tag
Einführung
Zend_Tag_Cloud
Zend_Test
Einführung
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
Zend_Tool_Framework
Einführung
Verwenden des CLI Tools
Architecture
Erstellen von Providern für die Verwendung mit Zend_Tool_Framework
Mitgelieferte System Provider
Zend_Tool_Project
Zend_Tool_Project Einführung
Ein Projekt erstellen
Project Provider für Zend Tool
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
Prüfungsmeldungen
Zend_Version
Die Version des Zend Frameworks erhalten
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Migration von vorhergehenden Versionen
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Zend Framework Voraussetzungen
Einführung
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Zend Framework Performance Guide
Einführung
Laden von Klassen
Zend_Db Performance
Internationalisierung (I18n) und Lokalisierung (L10n)
Darstellen der View
Urheberrecht Informationen