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

<?xml version="1.0" encoding="UTF-8"?>
    <!-- EN-Revision: 24249 -->
    <!-- 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>