repo_zf1/documentation/manual/es/module_specs/Zend_Controller-ActionHelpers-ViewRenderer.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!-- EN-Revision: 17597 -->
    <!-- Reviewed: no -->
<sect3 id="zend.controller.actionhelpers.viewrenderer">
    <title>ViewRenderer</title>

    <sect4 id="zend.controller.actionhelper.viewrenderer.introduction">
        <title>Introducción</title>

        <para>
            El ayudante
            <emphasis>ViewRenderer</emphasis>
            está diseñado
            para satisfacer los siguientes objetivos:
        </para>

        <itemizedlist>
            <listitem>
                <para>Eliminar la necesidad de instanciar objetos de vista
                    dentro de los
                    controladores; los objetos de vista quedarán
                    registrados automáticamente con el
                    contralor.</para>
            </listitem>

            <listitem>
                <para>Establece automáticamente el script de vista, el
                    ayudante, y los paths de los
                    filtros basados en el módulo
                    actual. Asocia automáticamente el nombre del módulo
                    actual
                    como un prefijo de clase para las clases ayudante y filtro.
               </para>
            </listitem>

            <listitem>
                <para>Crea un objeto de vista, disponible globalmente para
                    todos los controladores y
                    acciones despachados.</para>
            </listitem>

            <listitem>
                <para>Permite al desarrollador establecer por defecto las
                    opciones de renderizado
                    para todos los controladores.
               </para>
            </listitem>

            <listitem>
                <para>Agrega la capacidad para renderizar automáticamente los
                    scripts de vista sin
                    ninguna intervención.</para>
            </listitem>

            <listitem>
                <para>Permite al desarrollador crear sus propias
                    especificaciones para el path base
                    de vistas y para el path
                    de los scripts de vista.</para>
            </listitem>
        </itemizedlist>

        <note>
            <para>
                Si realiza un
                <methodname>_forward()</methodname>
                ,
                redirecciona, o
                <methodname>render()</methodname>
                manualmente, el
                autorendering no se llevará a cabo, como está realizando
                cualquiera de
                estas acciones le está diciendo al
                <emphasis>ViewRenderer</emphasis>
                que usted está
                determinando su propia salida.
            </para>
        </note>

        <note>
            <para>
                El
                <emphasis>ViewRenderer</emphasis>
                está habilitado por
                defecto. Puede desactivarlo vía parámetro del front controller
                <emphasis>noViewRenderer</emphasis>
                (<command>$front->setParam('noViewRenderer',true)</command>) 
				o eliminando al ayudante del stack de ayudantes
                (
				<methodname>
				Zend_Controller_Action_HelperBroker::removeHelper('viewRenderer')
				</methodname>
                ).
            </para>

            <para>
                Si desea modificar los settings del
                <emphasis>ViewRenderer</emphasis>
                antes de despachar el
                front controller, puede hacerlo en una de las dos maneras:
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        Instanciar y registrar su propio objeto
                        <emphasis>ViewRenderer</emphasis>
                        y pasarlo al
                        ayudante:
                    </para>

                    <programlisting language="php"><![CDATA[
$viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer();
$viewRenderer->setView($view)
             ->setViewSuffix('php');
Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);
]]></programlisting>
                </listitem>

                <listitem>
                    <para>
                        Inicializar y/o recuperar un objeto
                        <emphasis>ViewRenderer</emphasis>
                        por demanda
                        via el ayudante:
                    </para>

                    <programlisting language="php"><![CDATA[
$viewRenderer =
    Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
$viewRenderer->setView($view)
             ->setViewSuffix('php');
]]></programlisting>
                </listitem>
            </itemizedlist>
        </note>
    </sect4>

    <sect4 id="zend.controller.actionhelper.viewrenderer.api">
        <title>API</title>

        <para>
            En su uso más básico, simplemente instancie a
            <emphasis>ViewRenderer</emphasis>
            y páselo al ayudante de
            acciones. La forma más fácil para instanciar y registrar de una
            sola
            vez es utilizando el método del ayudante
            <methodname>getStaticHelper()</methodname>
            :
        </para>

        <programlisting language="php"><![CDATA[
Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
]]></programlisting>

        <para>
            La primera vez que se instancia un controlador de acción, se
            disparará
            <emphasis>ViewRenderer</emphasis>
            para instanciar al
            objeto vista. Cada vez que el controlador es instanciado, se llama
            al
            método
            <methodname>init()</methodname>
            de
            <emphasis>ViewRenderer</emphasis>
            , que lo llevará a
            establecer la propiedad del controlador de acción, y llama a
            <methodname>addScriptPath()</methodname>
            con un path relativo al
            módulo actual; este será llamado con un prefijo de clase nombrada
            después del módulo actual, haciendo efectivamente el namespacing de
            todas las clases de
            ayudantes y filtros que define para el módulo.
        </para>

        <para>
            Cad vez que llama a
            <methodname>postDispatch()</methodname>
            , este
            llamará a
            <methodname>render()</methodname>
            para la acción actual.
        </para>

        <para>Como ejemplo, considere la siguiente clase:</para>

        <programlisting language="php"><![CDATA[
// Una clase controlador, módulo foo:
class Foo_BarController extends Zend_Controller_Action
{
    // Render bar/index.phtml por defecto; no se requiere acción
    public function indexAction()
    {
    }

    // Render bar/populate.phtml con la variable 'foo' establecida a 'bar'.
    // Dado que el objeto vista está definido en preDispatch(),
    // ya está disponible.
    public function populateAction()
    {
        $this->view->foo = 'bar';
    }
}

...

// en uno de sus scripts de vista:
$this->foo(); // llama a Foo_View_Helper_Foo::foo()
]]></programlisting>

        <para>
            El
            <emphasis>ViewRenderer</emphasis>
            también define una serie
            de accededores para permitir establecer y recuperar opciones de
            vista:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <methodname>setView($view)</methodname>
                    le permite
                    establecer el objeto vista para
                    <emphasis>ViewRenderer</emphasis>
                    . Se vuelve como
                    una propiedad de clase pública
                    <varname>$view</varname>
                    .
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setNeverRender($flag = true)</methodname>
                    puede
                    ser utilizado para activar o desactivar globalmente el
                    autorendering, es
                    decir, para todos los controladores. Si es
                    verdadero,
                    <methodname>postDispatch()</methodname>
                    no
                    llamará automáticamente a
                    <methodname>render()</methodname>
                    en el controlador actual.
                    <methodname>getNeverRender()</methodname>
                    recupera el
                    valor actual.
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setNoRender($flag = true)</methodname>
                    puede ser
                    utilizado para activar o desactivar el autorendering. Si es
                    verdadero,
                    <methodname>postDispatch()</methodname>
                    no
                    llamará automáticamente a
                    <methodname>render()</methodname>
                    en el controlador actual. Este ajuste se reseteará cada vez
                    que se llame a
                    <methodname>preDispatch()</methodname>
                    (es
                    decir, usted necesita establecer este flag para cada
                    controlador para el cual
                    no quiera que el autorenderering se
                    ejecute).
                    <methodname>getNoRender()</methodname>
                    recupera el
                    valor actual.
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setNoController($flag = true)</methodname>
                    pude
                    ser usado para decirle a
                    <methodname>render()</methodname>
                    que no busque el script de acción en un subdirectorio
                    nombrado después de que el
                    controlador (que es el
                    comportamiento por defecto)
                    <methodname>getNoController()</methodname>
                    recupere el
                    valor actual.
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setNeverController($flag = true)</methodname>
                    es
                    análogo a
                    <methodname>setNoController()</methodname>
                    , pero
                    trabaja a un nivel global -- es decir, que no se reseteará
                    por cada acción
                    ejecutada.
                    <methodname>getNeverController()</methodname>
                    recupera
                    el valor actual.
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setScriptAction($name)</methodname>
                    puede ser
                    utilizado para especificar el script de acción a renderizar.
                    <varname>$name</varname>
                    debe ser el nombre del
                    script menos el sufijo del archivo (y sin el subdirectorio
                    del controlador, a menos que
                    <emphasis>noController</emphasis>
                    se haya activado).
                    Si no se ha especificado, busca un script de vista nombrado
                    después de la acción en el objeto solicitud.
                    <methodname>getScriptAction()</methodname>
                    recupera el
                    valor actual.
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setResponseSegment($name)</methodname>
                    puede ser
                    utilizado para especificar qué segmento del objeto respuesta
                    nombrado
                    renderizar. Si no se especifica, se hace en el
                    segmento por defecto.
                    <methodname>getResponseSegment()</methodname>
                    recupera
                    el valor actual.
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>initView($path, $prefix, $options)</methodname>
                    puede ser llamado para especificar el path base de las
                    vistas, prefijos de clase
                    para scripts de ayudantes y
                    filtros, y las opciones de
                    <emphasis>ViewRenderer</emphasis>
                    . Puede pasar
                    cualquiera de los siguientes flags:
                    <emphasis>neverRender</emphasis>
                    ,
                    <emphasis>noRender</emphasis>
                    ,
                    <emphasis>noController</emphasis>
                    ,
                    <emphasis>scriptAction</emphasis>
                    , y
                    <emphasis>responseSegment</emphasis>
                    .
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setRender($action = null, $name = null,
                        $noController = false)</methodname>
                    le permite
                    establecer cualquier
                    <emphasis>scriptAction</emphasis>
                    ,
                    <emphasis>responseSegment</emphasis>
                    , y
                    <emphasis>noController</emphasis>
                    en un pase.
                    <methodname>direct()</methodname>
                    es un alias a este
                    método, permitiéndole llamar a este método fácilmente dede
                    su
                    controlador:
                </para>

                <programlisting language="php"><![CDATA[
// Render 'foo' en lugar del script de acción actual
$this->_helper->viewRenderer('foo');

// render form.phtml al segmento de respuesta de 'html', sin usar un
// subdirectorio de scripts de controladores de acción:
$this->_helper->viewRenderer('form', 'html', true);
]]></programlisting>

                <note>
                    <para>
                        <methodname>setRender()</methodname>
                        y
                        <methodname>direct()</methodname>
                        realmente no
                        renderiza el script de vista, sino que establece
                        indicaciones que
                        <methodname>postDispatch()</methodname>
                        y
                        <methodname>render()</methodname>
                        utlizarán para
                        renderizar la vista.
                    </para>
                </note>
            </listitem>
        </itemizedlist>

        <para>
            El constructor le permite opcionalmente pasar el objeto vista y
            las opciones de
            <emphasis>ViewRenderer</emphasis>
            ; acepta los
            mismos flags que
            <methodname>initView()</methodname>
            :
        </para>

        <programlisting language="php"><![CDATA[
$view    = new Zend_View(array('encoding' => 'UTF-8'));
$options = array('noController' => true, 'neverRender' => true);
$viewRenderer =
    new Zend_Controller_Action_Helper_ViewRenderer($view, $options);
]]></programlisting>

        <para>Hay varios métodos adicionales para personalizar especificaciones
            del path, usados para
            determinar el path base del script de vista
            para añadir al objeto vista, y el path del
            script de vista a usar
            cuando esté autodeterminando el script de vista a renderizar. Cada
            uno de estos métodos toma uno o más de los siguientes localizadores:</para>

        <itemizedlist>
            <listitem>
                <para>
                    <emphasis>:moduleDir</emphasis>
                    hace referencia a la
                    actual directorio base del módulo(por convención, el
                    directorio padre del directorio del módulo controlador).
                </para>
            </listitem>

            <listitem>
                <para>
                    <emphasis>:module</emphasis>
                    hace referencia al nombre
                    del módulo actual.
                </para>
            </listitem>

            <listitem>
                <para>
                    <emphasis>:controller</emphasis>
                    hace referencia al
                    nombre del controlador actual.
                </para>
            </listitem>

            <listitem>
                <para>
                    <emphasis>:action</emphasis>
                    hace referencia al nombre
                    de la acción actual.
                </para>
            </listitem>

            <listitem>
                <para>
                    <emphasis>:suffix</emphasis>
                    hace referencia al sufijo
                    del script de vista (que puede ser definido via
                    <methodname>setViewSuffix()</methodname>
                    ).
                </para>
            </listitem>
        </itemizedlist>

        <para>Los métodos para controlar las especificaciones del path son:</para>

        <itemizedlist>
            <listitem>
                <para>
                    <methodname>setViewBasePathSpec($spec)</methodname>
                    le
                    permite cambiar la especificación del path utilizada para
                    determinar el path
                    base para añadir al objeto vista. La
                    especificación por defecto es
                    <filename>:moduleDir/views</filename>
                    . Puede
                    recuperar la especificación actual en cualquier momento
                    usando
                    <methodname>getViewBasePathSpec()</methodname>
                    .
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setViewScriptPathSpec($spec)</methodname>
                    le
                    permite cambiar el path de la especificación utilizada para
                    determinar el path
                    a un script de vista individual (menos el
                    path de la base del script de vista).
                    La especificación por
                    defecto es
                    <filename>:controller/:action.:suffix</filename>
                    .
                    Puede recuperar la especificación actual en cualquier
                    momento usando
                    <methodname>getViewScriptPathSpec()</methodname>
                    .
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setViewScriptPathNoControllerSpec($spec)</methodname>
                    le permite cambiar el path de la especificación utilizado
                    para determinar el path
                    a un script de vista individual
                    cuando
                    <emphasis>noController</emphasis>
                    está activado
                    (menos el path base del script de vista). La especificación
                    por
                    defecto es
                    <filename>:action.:suffix</filename>
                    .
                    Puede recuperar la especificación actual en cualquier
                    momento usando
                    <methodname>getViewScriptPathNoControllerSpec()</methodname>
                    .
                </para>
            </listitem>
        </itemizedlist>

        <para>
            Para un control más refinado sobre el path de especificaciones,
            puede usar
            <link linkend="zend.filter.inflector">Zend_Filter_Inflector</link>
            . Bajo el capó,
            <emphasis>ViewRenderer</emphasis>
            ya usa un inflector para
            realizar mapeos del path. Para interactuar con el inflector --
            ya
            sea para establecerlo para uso propio, o para modificar el inflector
            por defecto, se
            pueden utilizar los siguientes métodos:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <methodname>getInflector()</methodname>
                    recupera el
                    inflector. Si no existe todavía en
                    <emphasis>ViewRenderer</emphasis>
                    , se crea uno
                    utilizando las reglas predeterminadas.
                </para>

                <para>
                    Por defecto, utiliza reglas de referencias estáticas para
                    el sufijo y directorio
                    de módulos, así como una meta
                    estática; esto permite que diversas propiedades de
                    <emphasis>ViewRenderer</emphasis>
                    tengan la
                    capacidad de modificar dinámicamente al inflector.
                </para>
            </listitem>

            <listitem>
                <para>
                    <methodname>setInflector($inflector,
                        $reference)</methodname>
                    permite establecer un inflector
                    personalizado para usar con
                    <emphasis>ViewRenderer</emphasis>
                    . Si
                    <varname>$reference</varname>
                    es verdadero,
                    establecerá el sufijo y directorio de módulos como
                    referencias
                    estáticas a las propiedades de
                    <emphasis>ViewRenderer</emphasis>
                    , así como al
                    objetivo.
                </para>
            </listitem>
        </itemizedlist>

        <note>
            <title>Convenciones por Defecto para Lookup</title>

            <para>
                El
                <emphasis>ViewRenderer</emphasis>
                hace algún tipo de
                normalización del path para facilitar la búsqueda de los scripts
                de vista. Las reglas predeterminadas son los siguientes:
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        <emphasis>:module</emphasis>
                        : MixedCase y
                        camelCasedWords están separados por guiones, y el string
                        completo se convierte a minúsculas. Por ejemplo:
                        "FooBarBaz" pasa a ser
                        "foo-bar-baz".
                    </para>

                    <para>
                        Internamente, el inflector utiliza los filtros
                        <classname>Zend_Filter_Word_CamelCaseToDash</classname>
                        y
                        <classname>Zend_Filter_StringToLower</classname>
                        .
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <emphasis>:controller</emphasis>
                        : MixedCase y
                        camelCasedWords están separados por guiones; los
                        subrayados se
                        convierten en separadores de directorio ,
                        y el string emitido a minúsculas.
                        Ejemplos: "
                        <classname>FooBar</classname>
                        "
                        pasa a ser "foo-bar"; "
                        <classname>FooBar_Admin</classname>
                        " pasa a ser
                        "
                        <filename>foo-bar/admin</filename>
                        ".
                    </para>

                    <para>
                        Internamente, el inflector utiliza los filtros
                        <classname>Zend_Filter_Word_CamelCaseToDash</classname>
                        ,
                        <classname>Zend_Filter_Word_UnderscoreToSeparator</classname>
                        ,
                        y
                        <classname>Zend_Filter_StringToLower</classname>
                        .
                    </para>
                </listitem>

                <listitem>
                    <para>
                        <emphasis>:action</emphasis>
                        : MixedCase y
                        camelCasedWords están separados por guiones; los
                        caracteres no
                        alfanuméricos son traducidos a guiones, y
                        el string emitido a minúsculas.
                        Ejemplos: "fooBar" pasa
                        a ser "foo-bar"; "foo-barBaz" pasa a ser
                        "foo-bar-baz".
                    </para>

                    <para>
                        Internamente, el inflector utiliza los filtros
                        <classname>Zend_Filter_Word_CamelCaseToDash</classname>
                        ,
                        <classname>Zend_Filter_PregReplace</classname>
                        , y
                        <classname>Zend_Filter_StringToLower</classname>
                        .
                    </para>
                </listitem>
            </itemizedlist>
        </note>

        <para>
            Los últimos temas en la
            <acronym>API</acronym>
            de
            <emphasis>ViewRenderer</emphasis>
            son los métodos para
            determinar realmente los paths de los scripts de vista y el
            rendering de las vistas. Estos incluyen:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <methodname>renderScript($script, $name)</methodname>
                    permite renderizar un script con una ruta que especifique,
                    opcionalmente a un
                    segmento nombrado del path. Cuando se
                    utiliza este método,
                    <emphasis>ViewRenderer</emphasis>
                    no autodetermina el nombre del script, en cambio pasa
                    directamente a
                    <varname>$script</varname>
                    el argumento
                    directamente al método del objeto vista
                    <methodname>render()</methodname>
                    .
                </para>

                <note>
                    <para>
                        Una vez que la vista ha sido renderizada al objeto
                        respuesta, se establece
                        <emphasis>noRender</emphasis>
                        para evitar
                        accidentalmente renderizar el mismo script de vista
                        varias veces.
                    </para>
                </note>

                <note>
                    <para>
                        Por defecto,
                        <methodname>Zend_Controller_Action::renderScript()</methodname>
                        le delega a
                        <emphasis>ViewRenderer</emphasis>
                        el
                        método
                        <methodname>renderScript()</methodname>
                        .
                    </para>
                </note>
            </listitem>

            <listitem>
                <para>
                    <methodname>getViewScript($action, $vars)</methodname>
                    crea
                    el path a un script de vista basado en la acción pasada y/o
                    cualquier
                    variables pasadas en
                    <varname>$vars</varname>
                    . Las claves para este
                    array pueden incluir cualquiera de las claves de
                    especificación de paths ('moduleDir', 'module',
                    'controller', 'action', y
                    'suffix'). Se utilizarán
                    cualquiera de la variables pasadas; de lo contrario, se
                    utilizarán valores basados en la petición actual.
                </para>

                <para>
                    <methodname>getViewScript()</methodname>
                    utilizará tanto a
                    <emphasis>viewScriptPathSpec</emphasis>
                    o
                    <emphasis>viewScriptPathNoControllerSpec</emphasis>
                    sobre la base establecida del flag
                    <emphasis>noController</emphasis>
                    .
                </para>

                <para>
                    Los delimitadores de palabras encontrados en un módulo,
                    controlador o nombres de
                    acción serán reemplazados por
                    guiones ('-'). Así pues, si tiene el nombre de
                    controlador
                    '
                    <command>foo.bar</command>
                    ' y la acción '
                    <command>baz:bat</command>
                    ', utilizando la
                    especificación por defecto del path se traducirá en un path
                    al
                    script de vista '
                    <filename>foo-bar/baz-bat.phtml</filename>
                    '.
                </para>

                <note>
                    <para>
                        Por defecto,
                        <methodname>Zend_Controller_Action::getViewScript()</methodname>
                        delega el método
                        <methodname>getViewScript()</methodname>
                        de
                        <emphasis>ViewRenderer</emphasis>
                        .
                    </para>
                </note>
            </listitem>

            <listitem>
                <para>
                    <methodname>render($action, $name, $noController)</methodname>
                    comprueba primero para ver si bien
                    <varname>$name</varname>
                    o
                    <varname>$noController</varname>
                    se han pasado, y si es así, establece los flags apropiados 
					(responseSegment y  noController, respectivamente) en
                    <emphasis>ViewRenderer</emphasis>
                    . A continuación, pasa el argumento
                    <varname>$action</varname>
                    , si hay alguno, a
                    <methodname>getViewScript()</methodname>
                    . Por último, pasa el path calculado del script de vista a
                    <methodname>renderScript()</methodname>
                    .
                </para>

                <note>
                    <para>
                        Hay que ser conscientes de los efectos secundarios al
                        usar
                        <methodname>render()</methodname>
                        : los valores que usted pasa para el nombre
                        del segmento respuesta y para el
                        flag noController
                        persistirán en el objeto. Además, noRender será
                        establecido
                        después de completar la renderización.
                    </para>
                </note>

                <note>
                    <para>
                        Por defecto,
                        <methodname>Zend_Controller_Action::render()</methodname>
                        delega a
                        <emphasis>ViewRenderer</emphasis>
                        el método
                        <methodname>render()</methodname>
                        .
                    </para>
                </note>
            </listitem>

            <listitem>
                <para>
                    <methodname>renderBySpec($action, $vars, $name)</methodname>
                    permite pasar variables de especificación del path a fin de
                    determinar el path
                    para la creación del script de vista.
                    Este pasa
                    <varname>$action</varname>
                    y
                    <varname>$vars</varname>
                    a
                    <methodname>getScriptPath()</methodname>
                    , y luego pasa
                    el path del script resultante y
                    <varname>$name</varname>
                    a
                    <methodname>renderScript()</methodname>
                    .
                </para>
            </listitem>
        </itemizedlist>
    </sect4>

    <sect4 id="zend.controller.actionhelper.viewrenderer.basicusage">
        <title>Ejemplos Uso Básico</title>

        <example id="zend.controller.actionhelper.viewrenderer.basicusage.example-1">
            <title>Uso Básico</title>

            <para>
                En lo más básico, usted simplemente inicializa y registra el
                ayudante
                <emphasis>ViewRenderer</emphasis>
                con el ayudante
                broker en su bootstrap, y luego establecer las variables en sus
                métodos de acción.
            </para>

            <programlisting language="php"><![CDATA[
// En su bootstrap:
Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');

...

// 'foo' módulo, 'bar' controlador:
class Foo_BarController extends Zend_Controller_Action
{
    // Render bar/index.phtml por defecto; no se requieren acciones
    public function indexAction()
    {
    }

    // Render bar/populate.phtml la variable 'foo' establecida a 'bar'.
    // Dado que el objeto fue definido en preDispatch(), está disponible.
    public function populateAction()
    {
        $this->view->foo = 'bar';
    }

    // No hace rendering, ya que salta a otra acción; la nueva acción
    // realizará cualquier rendering
    public function bazAction()
    {
        $this->_forward('index');
    }

    // No hace rendering, ya que redirecciona a otra ubicación
    public function batAction()
    {
        $this->_redirect('/index');
    }
}
]]></programlisting>
        </example>

        <note>
            <title>Convenciones de Nombres: Delimitadores de Palabras en
                Controladores y Nombres de
                Acción</title>
            <para>
                Si su controlador o nombre de acción está compuesto por
                varias palabras, el
                despachador exige que estos sean separados
                de la
                <acronym>URL</acronym>
                por un path específico y caracteres
                delimitadores de palabras. El
                <emphasis>ViewRenderer</emphasis>
                reemplaza cualquier
                delimitador de paths encontrado en el nombre del controlador con
                el delimitador actual ('/'), y cualquier delimitador de palabra
                encontrado con un
                guión ('-') cuando crea paths. Así, una
                llamada a la acción
                <filename>/foo.bar/baz.bat</filename>
                despachará a
                <methodname>FooBarController::bazBatAction()</methodname>
                en
                <filename>FooBarController.php</filename>
                , el cual renderizaría a
                <filename>foo-bar/baz-bat.phtml</filename>
                ; una llamada
                a la acción
                <filename>/bar_baz/baz-bat</filename>
                despachará
                a
                <methodname>Bar_BazController::bazBatAction()</methodname>
                en
                <filename>Bar/BazController.php</filename>
                (note la
                separación del path) y renderiza
                <filename>bar/baz/baz-bat.phtml</filename>
                .
            </para>

            <para>
                Tener en cuenta que el en el segundo ejemplo, el módulo es
                todavía el módulo por
                defecto, pero que, debido a la existencia
                de un separador de paths, el controlador
                recibe el nombre
                <classname>Bar_BazController</classname>
                , en
                <filename>Bar/BazController.php</filename>
                . El
                <emphasis>ViewRenderer</emphasis>
                imita la jerarquía del directorio del controlador.
            </para>
        </note>

        <example id="zend.controller.actionhelper.viewrenderer.basicusage.example-2">
            <title>Deshabilitando Autorender</title>

            <para>
                Para algunas acciones o controladores, usted puede querer
                apagar el autorendering --
                por ejemplo, si quiere emitir un tipo
                diferente de salida (
                <acronym>XML</acronym>
                ,
                <acronym>JSON</acronym>
                , etc), o si simplemente no desea
                emitir nada. Tiene dos opciones: apagar todos los
                casos de
                autorendering (
                <methodname>setNeverRender()</methodname>
                ), o
                simplemente desactivarlo para la acción actual
                (
                <methodname>setNoRender()</methodname>
                ).
            </para>

            <programlisting language="php"><![CDATA[
// Baz clase del controlador, bar módulo:
class Bar_BazController extends Zend_Controller_Action
{
    public function fooAction()
    {
        // No auto renderize esta acción
        $this->_helper->viewRenderer->setNoRender();
    }
}

// Bat clase del controlador, bar módulo:
class Bar_BatController extends Zend_Controller_Action
{
    public function preDispatch()
    {
        // Nunca auto renderizar las acciones de este controlador
        $this->_helper->viewRenderer->setNoRender();
    }
}
]]></programlisting>
        </example>

        <note>
            <para>
                En muchos casos, no tiene sentido desactivar el autorendering
                globalmente (ala
                <methodname>setNeverRender()</methodname>
                ), y
                la única cosa que puede ganar de
                <emphasis>ViewRenderer</emphasis>
                es el autosetup del
                objeto de vista.
            </para>
        </note>

        <example id="zend.controller.actionhelper.viewrenderer.basicusage.example-3">
            <title>Eligiendo Un Script de Vista Diferente</title>

            <para>
                Algunas situaciones requieren renderizar un script diferente
                al llamado después de la
                acción. Por ejemplo, si tiene un
                controlador que tiene tanto las acciones de agregar
                y de editar,
                ambos pueden mostrar la misma vista 'form', aunque con
                diferentes valores
                establecidos. Puede cambiar fácilmente el
                nombre del script usado tanto con
                <methodname>setScriptAction()</methodname>
                ,
                <methodname>setRender()</methodname>
                , o llamando al ayudante
                como un método, que invocará a
                <methodname>setRender()</methodname>
                .
            </para>

            <programlisting language="php"><![CDATA[
// Bar clase controlador, foo módulo:
class Foo_BarController extends Zend_Controller_Action
{
    public function addAction()
    {
        // Render 'bar/form.phtml' en lugar de 'bar/add.phtml'
        $this->_helper->viewRenderer('form');
    }

    public function editAction()
    {
        // Render 'bar/form.phtml' en lugar de 'bar/edit.phtml'
        $this->_helper->viewRenderer->setScriptAction('form');
    }

    public function processAction()
    {
        // hacer alguna validación...
        if (!$valid) {
            // Render 'bar/form.phtml' en lugar de 'bar/process.phtml'
            $this->_helper->viewRenderer->setRender('form');
            return;
        }

        // de otra manera, continuar procesando...
    }

}
]]></programlisting>
        </example>

        <example id="zend.controller.actionhelper.viewrenderer.basicusage.example-4">
            <title>Modificando la Vista Registrada</title>

            <para>
                ¿Y si se necesita modificar el objeto vista -- por ejemplo,
                cambiar el ayudante de
                paths, o la codificación?. Puede hacerlo
                ya sea por modificar el objeto vista
                establecido en su
                controlador, o arrebatándole el objeto vista a
                <emphasis>ViewRenderer</emphasis>
                ; ambas son referencias
                al mismo objeto.
            </para>

            <programlisting language="php"><![CDATA[
// Bar clase controlador, foo módulo:
class Foo_BarController extends Zend_Controller_Action
{
    public function preDispatch()
    {
        // cambiar la codificavión de la vista
        $this->view->setEncoding('UTF-8');
    }

    public function bazAction()
    {
        // Obtener el objeto vista y establecer
        // el callback de escape a 'htmlspecialchars'
        $view = $this->_helper->viewRenderer->view;
        $view->setEscape('htmlspecialchars');
    }
}
]]></programlisting>
        </example>
    </sect4>

    <sect4 id="zend.controller.actionhelper.viewrenderer.advancedusage">
        <title>Ejemplos de Uso Avanzado</title>

        <example id="zend.controller.actionhelper.viewrenderer.advancedusage.example-1">
            <title>Cambiando las Especificaciones del Path</title>

            <para>
                En algunas circunstancias, puede decidir que las
                especificaciones del path por
                defecto no se adaptan a su sitio.
                Por ejemplo, usted puede querer tener un árbol
                único de
                plantillas al que puede dar acceso a sus diseñadores (esto es
                muy típico
                cuando se utiliza
                <ulink url="http://smarty.php.net/">Smarty</ulink>
                , por ejemplo). En ese caso, puede querer
                embeber los datos de la especificación del
                path base de la
                vista, y crear una especificación alternativa para el script de
                vista
                del path ellos mismos.
            </para>

            <para>
                Para los fines de este ejemplo, supongamos que el path base
                de las vistas debería ser
                '
                <filename>/opt/vendor/templates</filename>
                ', y que desea
                para que los scripts de vista sean referenciados por
                '
                <filename>:moduleDir/:controller/:action.:suffix</filename>
                '; si el flag
                <emphasis>noController</emphasis>
                ha sido establecido, quiere renderizar fuera del
                nivel superior en lugar de en un
                subdirectorio
                (
                <filename>':action.:suffix</filename>
                '). Por último, que quiere utilizar 'tpl' como
                el sufijo del nombre de archivo del
                script de vista.
            </para>

            <programlisting language="php"><![CDATA[
/**
 * En su bootstrap:
 */

// Implementación de una vista diferente
$view = new ZF_Smarty();

$viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer($view);
$viewRenderer->setViewBasePathSpec('/opt/vendor/templates')
             ->setViewScriptPathSpec(':module/:controller/:action.:suffix')
             ->setViewScriptPathNoControllerSpec(':action.:suffix')
             ->setViewSuffix('tpl');
Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);
]]></programlisting>
        </example>

        <example id="zend.controller.actionhelper.viewrenderer.advancedusage.example-2">
            <title>Rendering Múltiples Scripts de Vista desde una Sola
                Acción</title>

            <para>
                A veces, puede que necesite renderizar múltiples scripts de
                vista desde una sola
                acción. Esto es muy sencillo -- simplemente
                hacer múltiples llamadas a
                <methodname>render()</methodname>
                :
            </para>

            <programlisting language="php"><![CDATA[
class SearchController extends Zend_Controller_Action
{
    public function resultsAction()
    {
        // Suponga que $this->model es el modelo actual
        $this->view->results =
            $this->model->find($this->_getParam('query', '');

        // render() por defecto lo delega al ViewRenderer
        // Render primero al from de búsqueda y luego los resultados
        $this->render('form');
        $this->render('results');
    }

    public function formAction()
    {
        // No hacer nada; ViewRenderer hace autorender del script de vista
    }
}
]]></programlisting>
        </example>
    </sect4>
</sect3>