smarty-php/smarty
1
0
Fork 0
mirror of https://github.com/smarty-php/smarty.git synced 2025-11-05 23:01:37 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
f8011f6acb6d12246e790cb5e90dda1324fc54c7
smarty/docs/pt_BR/programmers.sgml

3276 lines
122 KiB
Plaintext
Raw Normal View History

add portuguese docs
2003-12-23 15:53:39 +00:00
<part id="smarty.for.programmers"><!-- En Version: 1.47 -->
<title>Smarty para Programadores</title>
<chapter id="smarty.constants">
<title>Constantes</title>
<para></para>
<sect1 id="constant.smarty.dir">
<title>SMARTY_DIR</title>
<para>
Isso deve ser o caminho completo do path para a localiza<7A><61>o dos arquivos de classe da Smarty.
Se isso n<>o for definido, ent<6E>o a Smarty ir<69> tentar determinar
o valor apropriado automaticamente. Se definido, o path
deve finalizar com uma barra.
</para>
<example>
<title>SMARTY_DIR</title>
<programlisting>
// set path to Smarty directory
define("SMARTY_DIR","/usr/local/lib/php/Smarty/");
require_once(SMARTY_DIR."Smarty.class.php");</programlisting>
</example>
</sect1>
</chapter>
<chapter id="api.variables">
<title>Vari<72>veis</title>
<sect1 id="variable.template.dir">
<title>$template_dir</title>
<para>
Este <20> o nome padr<64>o do diret<65>rio de template. Se voc<6F> n<>o fornecer
um tipo de recurso quando incluir arquivos, ent<6E>o ele ir<69> ser encontrado aqui.
Por padr<64>o isso <20> "./templates", significando que isso ir<69>
olhar para o diret<65>rio de templates no mesmo diret<65>rio que est<73> executando
o script PHP.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
N<>o <20> recomendado colocar este diret<65>rio sob um diret<65>rio
document root do seu webserver.
</para>
</note>
</sect1>
<sect1 id="variable.compile.dir">
<title>$compile_dir</title>
<para>
Esse <20> o nome do diret<65>rio onde os template compilados est<73>o localizados
Por padr<64>o isso <20> "./templates_c", significando que isso ir<69>
olhar para o diret<65>rio de templates no mesmo diret<65>rio que est<73> executando
o script PHP.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
Essa configura<72><61>o deve ser um path relativo ou um path absoluto.
include_path n<>o <20> usado para escrever em arquivos.
</para>
</note>
<note>
<title>Notas T<>cnicas</title>
<para>
N<>o <20> recomendado colocar este diret<65>rio sob um diret<65>rio
document root do seu webserver.
</para>
</note>
</sect1>
<sect1 id="variable.config.dir">
<title>$config_dir</title>
<para>
Este <20> o diret<65>rio usado para armazenar arquivos de configura<72><61>o usados nos
templates. O padr<64>o <20> "./configs", significando que isso ir<69>
olhar para o diret<65>rio de templates no mesmo diret<65>rio que est<73> executando
o script PHP.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
N<>o <20> recomendado colocar este diret<65>rio sob um diret<65>rio
document root do seu webserver.
</para>
</note>
</sect1>
<sect1 id="variable.plugins.dir">
<title>$plugins_dir</title>
<para>
Esse <20> o diret<65>rio onde Smarty ir<69> procurar por plugins que s<>o necess<73>rios.
O Padr<64>o <20> "plugins" sob o SMARTY_DIR. Se voc<6F>es especificar um
path relativo, Smarty ir<69> primeiro procurar sob o SMARTY_DIR, ent<6E>o
relativo para o cwd (current working directory), ent<6E>o relativo para cada
entrada no seu PHP include path.
</para>
<note>
<title>Notas t<>cnicas</title>
<para>
Para uma melhor performance, n<>o configure seu plugins_dir para ter que usar o
PHP include path. Use um path absoluto, ou um path relativo para
SMARTY_DIR ou o cwd.
</para>
</note>
</sect1>
<sect1 id="variable.debugging">
<title>$debugging</title>
<para>
Isso habilita o <link
linkend="chapter.debugging.console">debugging console</link>.
O console <20> uma janela de javascript que informa <20> voc<6F>
sobre os arquivos de template inclu<6C>dos e vari<72>veis
destinadas para a p<>gina de template atual.
</para>
</sect1>
<sect1 id="variable.debug.tpl">
<title>$debug_tpl</title>
<para>
Este <20> o nome do arquivo de template usado para o console de debug.
Por padr<64>o, <20> nomeado como debug.tpl e est<73> localizado no <link
linkend="constant.smarty.dir">SMARTY_DIR</link>.
</para>
</sect1>
<sect1 id="variable.debugging.ctrl">
<title>$debugging_ctrl</title>
<para>
Isso permite caminhos alternativos de habilitar o debug. NONE n<>o significa
que m<>todos alternativos s<>o permitidos. URL significa quando a palavra
SMARTY_DEBUG foi encontrado na QUERY_STRING, que o debug est<73> habilitado
para a chamada do script.
Se $debugging <20> true, esse valor <20> ignorado.
</para>
</sect1>
<sect1 id="variable.global.assign">
<title>$global_assign</title>
<para>
Essa <20> a lista de vari<72>veis que est<73>o sempre implicitamente fixadas
para o template engine. Isso est<73> acess<73>vel para fazer vari<72>veis
globais ou vari<72>veis do servidor dispon<6F>veis para todo o template
sem ter que fix<69>-las manualmente. Cada elemento em
$global_assign deve ser um nome de uma vari<72>vel global,
ou um par de chave/valor, onde a chave <20> o nome do array global
array e o valor <20> o array de vari<72>veis fixadas deste array global. $SCRIPT_NAME <20>
globalmente fixado por padr<64>o
para $HTTP_SERVER_VARS.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
Vari<72>veis de servidor podem ser acessadas atrav<61>s da vari<72>vel
$smarty, como {$smarty.server.SCRIPT_NAME}. Veja a se<73><65>o
da vari<72>vel
<link linkend="language.variables.smarty">$smarty</link>.
</para>
</note>
</sect1>
<sect1 id="variable.undefined">
<title>$undefined</title>
<para>
Isso seta o valor de $undefined para Smarty, o padr<64>o <20> null.
Atualmente isso <20> somente usado para setar vari<72>veis indefinidas em
$global_assign para o valor padr<64>o.
</para>
</sect1>
<sect1 id="variable.autoload.filters">
<title>$autoload_filters</title>
<para>
Se h<> algum filtro que voc<6F> deseja carregar em cada chamada de template,
voc<6F> pode especificar-lhes usando essa vari<72>vel e a Smarty ir<69>
automaticamente carreg<65>-los para voc<6F>. A vari<72>vel <20> um array associativo
onde as chaves s<>o tipos de filtro e os valores s<>o arrays de nomes de filtros.
Por exemplo:
<informalexample>
<programlisting>
$smarty-&gt;autoload_filters = array('pre' =&gt; array('trim', 'stamp'),
'output' => array('convert'));
</programlisting>
</informalexample>
</para>
</sect1>
<sect1 id="variable.compile.check">
<title>$compile_check</title>
<para>
Em cima de cada requisi<73><69>o da aplica<63><61>o PHP , Smarty testa para ver se o
template atual foi alterado (diferentes time stamp) desde a <20>ltima
compila<6C><61>o. Se isso foi alterado, ele ir<69> recompilar o template. Se o template
n<>o foi compilado, ele ir<69> compilar de qualquer maneira dessa configura<72><61>o.
Por padr<64>o esta vari<72>vel <20> setada como true. Uma vez que a aplica<63><61>o est<73>
em produ<64><75>o (templates n<>o ser<65>o alterados), o passo compile_check
n<>o <20> necess<73>rio. Tenha certeza de setar $compile_check para "false" para
maior performance. Note que se voc<6F> alterar isso para "false" e o
arquivo de template est<73> alterado, voc<6F> *n<>o* ir<69> ver a altera<72><61>o desde que
o template seja recompilado. Se caching est<73> habilitado e
compile_check est<73> habilitado, ent<6E>o os arquivos de cache n<>o ser<65>o regerados se
um complexo arquivo de ou um arquivo de configura<72><61>o foi atualizado. Veja <link
linkend="variable.force.compile">$force_compile</link> ou <link
linkend="api.clear.compiled.tpl">clear_compiled_tpl</link>.
</para>
</sect1>
<sect1 id="variable.force.compile">
<title>$force_compile</title>
<para>
Isso for<6F>a Smarty para (re)compilar templates a cada requisi<73><69>o.
Essa configura<72><61>o sobreescreve $compile_check. Por padr<64>o
isso est<73> desabilitado. Isso <20> <20>til para desenvolvimento e debug.
Isso nunca deve ser usado em ambiente de produ<64><75>o. Se caching
est<73> habilitado, os arquivo(s) de cache ser<65>o regerados <20> todo momento.
</para>
</sect1>
<sect1 id="variable.caching">
<title>$caching</title>
<para>
Isto diz <20> Smarty se h<> ou n<>o sa<73>da de cache para o template.
Por padr<64>o isso est<73> setado para 0, ou desabilitado. Se seu template gerar
conte<74>do redundante, <20> necess<73>rio ligar o caching. Isso
ir<69> resultar num ganho significativo de performance. Voc<6F> pode tamb<6D>m ter m<>ltiplos
caches para o mesmo template. Um valor de 1 ou 2 caching habilitados. 1 diz
<20> Smarty para usar a vari<72>vel atual $cache_lifetime para determinar se o
cache expirou. Um valor 2 diz <20> Smarty para usar o valor cache_lifetime
ent<6E>o para quando o cache foi gerado. Desta maneira voc<6F> pode setar o
cache_lifetime imediatamente antes de buscar o template para ter controle
sobre quando este cache em particular expira. Veja tamb<6D>m <link
linkend="api.is.cached">is_cached</link>.
</para>
<para>
Se $compile_check est<73> habilitado, o conte<74>do do cache ir<69> ser regerado se
algum dos templates ou arquivos de configura<72><61>o que s<>o parte deste cache estiverem
alterados. Se $force_compile est<73> habilitado, o conte<74>do do cache ir<69> sempre ser
regerado.
</para>
</sect1>
<sect1 id="variable.cache.dir">
<title>$cache_dir</title>
<para>
Isso <20> o nome do diret<65>rio onde os caches do template s<>o
armazenados. Por padr<64>o isso <20> "./cache", significando que isso ir<69> olhar
para o diret<65>rio de cache no mesmo diret<65>rio que executar scripts PHP.
Voc<6F> pode tambe usar sua pr<70>pria fun<75><6E>o customizada de manuseamento de cache
para manipular arquivos de cache,
que ir<69>o ignorar esta configura<72><61>o.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
Essa configura<72><61>o deve ser ou um relativo
ou absoluto path. include_path n<>o <20> usado para escrever em arquivos.
</para>
</note>
<note>
<title>Notas T<>cnicas</title>
<para>
N<>o <20> recomendado colocar este diret<65>rio sob um diret<65>rio
document root do seu webserver.
</para>
</note>
</sect1>
<sect1 id="variable.cache.lifetime">
<title>$cache_lifetime</title>
<para>
Isso <20> o comprimento de tempo em segundos que um cache de template <20> v<>lido.
Uma vez que este tempo est<73> expirado, o cache ir<69> ser regerado. $caching deve
ser configurado para "true" para $cache_lifetime para ter algum prop<6F>sito. Um valor de -1
ir<69> for<6F>ar o cache a nunca expirar. Um valor de 0 ir<69> fazer com que o cache seja sempre regerado
(bom somente para testes, o m<>todo mais eficiente de desabilitar caching <20> set<65>-lo para
<link
linkend="variable.caching">$caching</link> = false.)
</para>
<para>
Se <link linkend="variable.force.compile">$force_compile</link> est<73>
habilitado, os arquivos de cache ser<65>o regerados todo o tempo, eficazmente
desativando caching. Voc<6F> pode limpar todos os arquivos de cache com a fun<75><6E>o <link
linkend="api.clear.all.cache">clear_all_cache()</link>, ou
arquivos individuais de cache (ou grupos) com a fun<75><6E>o <link
linkend="api.clear.cache">clear_cache()</link>.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
Se voc<6F> quiser dar para certos templates seu pr<70>prio tempo de vida de um cache,
voc<6F> poderia fazer isso configurando <link linkend="variable.caching">$caching</link> = 2,
ent<6E>o configure $cache_lifetime para um <20>nico valor somente antes de chamar display()
ou fetch().
</para>
</note>
</sect1>
<sect1 id="variable.cache.handler.func">
<title>$cache_handler_func</title>
<para>
Voc<6F> pode fornecer uma fun<75><6E>o padr<64>o para manipular arquivos de cache ao inv<6E>s de
usar o m<>todo built-in usando o $cache_dir. Veja a
se<73><65>o <link linkend="section.template.cache.handler.func">cache
handler function section</link> para obter detalhes.
</para>
</sect1>
<sect1 id="variable.cache.modified.check">
<title>$cache_modified_check</title>
<para>
Se configurado para true, Smarty ir<69> respeitar o If-Modified-Since
header enviado para o cliente. Se o timestamp do arquivo de cache
n<>o foi alterado desde a <20>ltima visita, ent<6E>o um header "304 Not Modified"
ir<69> ser enviado ao inv<6E>s do conte<74>do. Isso funciona somente em arquivos
de cache sem tags <command>insert</command>.
</para>
</sect1>
<sect1 id="variable.config.overwrite">
<title>$config_overwrite</title>
<para>
Se configurado para true, vari<72>veis lidas no arquivo de configura<72><61>es ir<69>o sobrescrever
uma a outra. Do contr<74>rio, as vari<72>veis ser<65>o guardadas em um array. Isso <20>
<20>til se voc<6F> quer armazenar arrays de dados em arquivos de configura<72><61>o, somente lista
tempos de cada elemento m<>ltiplo. true por padr<64>o.
</para>
</sect1>
<sect1 id="variable.config.booleanize">
<title>$config_booleanize</title>
<para>
Se setado para true, os valores do arquivo de configura<72><61>o de on/true/yes e off/false/no
ficar<61> convertido para valores booleanos automaticamente. Desta forma voc<6F> pode usar os
valores em um template como: {if #foobar#} ... {/if}. Se foobar estiver
on, true ou yes, a condi<64><69>o {if} ir<69> executar. true por padr<64>o.
</para>
</sect1>
<sect1 id="variable.config.read.hidden">
<title>$config_read_hidden</title>
<para>
Se configurado para true, esconde se<73><65>es (nomes de se<73><65>es come<6D>ados com um per<65>odo)
no arquivo de configura<72><61>o podem ser lidos do template. Tipicamente voc<6F> deixaria
isto como false, desta forma voc<6F> pode armazenar dados sensitivos no arquivo de configura<72><61>o
como um par<61>metro de banco de
dados e sem preocupar-se sobre o template carreg<65>-los. false <20> o padr<64>o.
</para>
</sect1>
<sect1 id="variable.config.fix.newlines">
<title>$config_fix_newlines</title>
<para>
Se setado para true, mac e dos newlines (\r e \r\n) no arquivo de configura<72><61>o ser<65>o
convertidos para \n quando eles forem interpretados. true <20> o padr<64>o.
</para>
</sect1>
<sect1 id="variable.default.template.handler.func">
<title>$default_template_handler_func</title>
<para>
Essa fun<75><6E>o <20> chamada quando um template n<>o pode ser obtido
de seu recurso.
</para>
</sect1>
<sect1 id="variable.php.handling">
<title>$php_handling</title>
<para>
Isso diz <20> Smarty como manipular c<>digos PHP contido nos
templates. H<> quatro poss<73>veis configura<72><61>es, padr<64>o sendo
SMARTY_PHP_PASSTHRU. Note que isso N<>O far<61> efeito com c<>digos php
dentro de tags <link linkend="language.function.php">{php}{/php}</link>
no template.
</para>
<itemizedlist>
<listitem><para>SMARTY_PHP_PASSTHRU - Smarty echos tags as-is.</para></listitem>
<listitem><para>SMARTY_PHP_QUOTE - Smarty quotes the
tags as html entities.</para></listitem>
<listitem><para>SMARTY_PHP_REMOVE - Smarty
ir<69> remover as tags do template.</para></listitem>
<listitem><para>SMARTY_PHP_ALLOW - Smarty ir<69> executar as
tags como c<>digos PHP.</para></listitem>
</itemizedlist>
<para>
NOTE: Usando c<>digos PHP code dentro de templates <20> altamente desencorajado.
Use <link linkend="language.custom.functions">custom functions</link> ou
<link linkend="language.modifiers">modifiers</link> ao inv<6E>s disso.
</para>
</sect1>
<sect1 id="variable.security">
<title>$security</title>
<para>
$security true/false, o padr<64>o <20> false. Security <20> bom para situa<75><61>es
quando voc<6F> tem partes inconfi<66>veis editando o template
(via ftp por exemplo) e voc<6F> quer reduzir os riscos de comprometimento
da seguran<61>a do sistema atrav<61>s da linguagem de template.
Habilitando-o faz-se cumprir as regras da linguagem de template,
a menos que especificamente cancelada com $security_settings:
</para>
<itemizedlist>
<listitem><para>Se $php_handling est<73> setado para SMARTY_PHP_ALLOW, isso <20> implicitamente
alterado para SMARTY_PHP_PASSTHRU</para></listitem>
<listitem><para>Fun<75><6E>s PHP n<>o s<>o permitidas em blocos IF,
exceto estes especificados no $security_settings</para></listitem>
<listitem><para>templates podem ser somente incluidos no diret<65>rio
listado em $secure_dir array</para></listitem>
<listitem><para>Arquivos locais podem ser somente trazidos do diret<65>rio
listado em $secure_dir usando no array {fetch}</para></listitem>
<listitem><para>Estas tags {php}{/php} n<>o s<>o permitidas</para></listitem>
<listitem><para>Fun<75><6E>es PHP n<>o s<>o permitidas como modificadores, exceto
estes especificados no $security_settings</para></listitem>
</itemizedlist>
</sect1>
<sect1 id="variable.secure.dir">
<title>$secure_dir</title>
<para>
Isso <20> um array de todos os diret<65>rios locais que s<>o considerados
seguros. {include} e {fetch} usam estes (diret<65>rios) quando security est<73> habilitado.
</para>
</sect1>
<sect1 id="variable.security.settings">
<title>$security_settings</title>
<para>
Essas configura<72><61>es s<>o usadas para cancelar ou especificar configura<72><61>es
de seguran<61>a quando security est<73> habilitado. Estas possuem as seguintes configura<72><61>es poss<73>veis:
</para>
<itemizedlist>
<listitem><para>PHP_HANDLING - true/false. Se setado para true,
a configura<72><61>o de $php_handling n<>o <20> checada para security.</para></listitem>
<listitem><para>IF_FUNCS - Isso <20> um array de nomes de fun<75><6E>es PHP permitidas
nos blocos IF.</para></listitem>
<listitem><para>INCLUDE_ANY - true/false. Se setado para true, algum
template pode ser inclu<6C>do para um arquivo do sistema, apesar de toda a lista de
$secure_dir.</para></listitem>
<listitem><para>PHP_TAGS - true/false. Se setado para true, as tags {php}{/php}
s<>o permitidas nos templates.</para></listitem>
<listitem><para>MODIFIER_FUNCS - Isso <20> um array de nomes de fun<75><6E>es PHP permitidas
usadas como modificadores de vari<72>vel.</para></listitem>
</itemizedlist>
</sect1>
<sect1 id="variable.trusted.dir">
<title>$trusted_dir</title>
<para>
$trusted_dir somente usado quando $security est<73> habilitado. Isso <20> um array
de todos os diret<65>rios que s<>o considerados confi<66>veis. Diret<65>rios confi<66>veis
s<>o onde voc<6F> ir<69> deixar seus scripts php que s<>o executados diretamente para o
template com <link linkend="language.function.include.php">{include_php}</link>.
</para>
</sect1>
<sect1 id="variable.left.delimiter">
<title>$left_delimiter</title>
<para>
Este <20> o delimitador esquerdo usado para a linguagem de template.
O padr<64>o <20> "{".
</para>
</sect1>
<sect1 id="variable.right.delimiter">
<title>$right_delimiter</title>
<para>
Este <20> o delimitador direito usado para a linguagem de template.
O padr<64>o <20> "}".
</para>
</sect1>
<sect1 id="variable.compiler.class">
<title>$compiler_class</title>
<para>
Especifica o nome do compilador de classes que
Smarty ir<69> usar para compilar templates. O padr<64>o <20> 'Smarty_Compiler'.
Para usu<73>rios avan<61>ados somente.
</para>
</sect1>
<sect1 id="variable.request.vars.order">
<title>$request_vars_order</title>
<para>
A ordem na qual as vari<72>veis requeridas ser<65>o registradas, similar ao
variables_order no php.ini
</para>
</sect1>
<sect1 id="variable.request.use.auto.globals">
<title>$request_use_auto_globals</title>
<para>
Especifica se a Smarty deve usar vari<72>veis globais do php $HTTP_*_VARS[]
($request_use_auto_globals=false que <20> o valor padr<64>o) ou
$_*[] ($request_use_auto_globals=true). Isso afeta templates
que fazem uso do {$smarty.request.*}, {$smarty.get.*} etc. .
Aten<65><6E>o: Se voc<6F> setar $request_use_auto_globals para true, <link
linkend="variable.request.vars.order">variable.request.vars.order
</link> n<>o ter<65>o efeito mas valores de configura<72><61>es do php
<literal>gpc_order</literal> s<>o usados.
</para>
</sect1>
<sect1 id="variable.compile.id">
<title>$compile_id</title>
<para>
Identificador de compila<6C><61>o persistente. Como uma alternativa
para passar o mesmo compile_id para cada chamada de fun<75><6E>o, voc<6F>
pode setar este compile_id e isso ir<69> ser usado implicitamente ap<61>s isso.
</para>
</sect1>
<sect1 id="variable.use.sub.dirs">
<title>$use_sub_dirs</title>
<para>
Configure isso para false se seu ambiente de PHP n<>o permite a cria<69><61>o de
subdiret<65>rios pela Smarty. Subdiret<65>rios s<>o muito eficientes, ent<6E>o use-os se voc<6F>
conseguir.
</para>
</sect1>
<sect1 id="variable.default.modifiers">
<title>$default_modifiers</title>
<para>
Isso <20> um array de modificadores implicitamente aplicados par cada
vari<72>vel no template. Por Exemplo, para cada vari<72>vel HTML-escape por padr<64>o,
use o array('escape:"htmlall"'); Para fazer a vari<72>vel isenta para modificadores
padr<64>o, passe o modificador especial "smarty" com um valor de par<61>metro "nodefaults"
modificando isso, como
{$var|smarty:nodefaults}.
</para>
</sect1>
<sect1 id="variable.default.resource.type">
<title>$default_resource_type</title>
<para>
Isso diz <20> Smarty qual tipo de recurso usar implicitamente.
O valor padr<64>o <20> 'file', significando que $smarty->display('index.tpl'); e
$smarty->display('file:index.tpl'); s<>o id<69>nticos no significado.
Veja o cap<61>tulo <link linkend="template.resources">resource</link> para detalhes.
</para>
</sect1>
</chapter>
<chapter id="api.functions">
<title>M<>todos</title>
<sect1 id="api.append">
<title>append</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>append</function></funcdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
</funcprototype>
<funcprototype>
<funcdef>void <function>append</function></funcdef>
<paramdef>string <parameter>varname</parameter></paramdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
</funcprototype>
<funcprototype>
<funcdef>void <function>append</function></funcdef>
<paramdef>string <parameter>varname</parameter></paramdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
<paramdef>boolean <parameter>merge</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso <20> usado para adicionar um elemento para um array fixado. Se voc<6F> adicionar
uma string como valor, isso ir<69> converter-se para um valor de array e ent<6E>o adicion<6F>-lo.
Voc<6F> pode explicitamente passar pares nomes/valores, ou arrays associativos
contendo o par nome/valor. Se voc<6F> passar o terceiro par<61>metro opcional para true,
o valor unir-se ao array atual
ao inv<6E>s de ser adicionado.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
O par<61>metro de uni<6E>o respeita a chave do array, ent<6E>o se voc<6F>
mesclar dois <20>ndices n<>mericos de um array, eles devem sobrescrever-se
um ao outro ou em resultados n<>o sequ<71>ncias de chave. Isso <20> diferente da fun<75><6E>o de PHP array_merge()
que apaga as chaves e as renumera.
</para>
</note>
<example>
<title>append</title>
<programlisting>
// passing name/value pairs
$smarty->append("Name","Fred");
$smarty->append("Address",$address);
// passing an associative array
$smarty->append(array("city" => "Lincoln","state" => "Nebraska"));</programlisting>
</example>
</sect1>
<sect1 id="api.append.by.ref">
<title>append_by_ref</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>append_by_ref</function></funcdef>
<paramdef>string <parameter>varname</parameter></paramdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
</funcprototype>
<funcprototype>
<funcdef>void <function>append_by_ref</function></funcdef>
<paramdef>string <parameter>varname</parameter></paramdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
<paramdef>boolean <parameter>merge</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso <20> usado para adicionar vlaores para o template por refer<65>ncia.
Se voc<6F> adicionar uma vari<72>vel por refer<65>ncia e ent<6E>o alterar este valor
o valor adicionado enxergar<61> a altera<72><61>o tamb<6D>m. Para objetos,
append_by_ref() tamb<6D>m evita uma c<>pia em mem<65>ria do objeto adicionado.
Veja o manual do PHP em referenciando vari<72>veis para uma melhor explana<6E><61>o sobre o assunto.
Se voc<6F> passar o terceiro par<61>metro opcional para true,
o valor ir<69> ser mesclado com o array atual ao inv<6E>s de adicion<6F>-lo.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
O par<61>metro de uni<6E>o respeita a chave do array, ent<6E>o se voc<6F> mesclar
dois <20>ndices n<>mericos de arrays, eles devem sobrescrever-se um ao outro ou
em resultados n<>o sequ<71>ncias de chave. Isso <20> diferente da fun<75><6E>o de PHP array_merge()
que apaga as chaves num<75>ricas e as renumera.
</para>
</note>
<example>
<title>append_by_ref</title>
<programlisting>
// appending name/value pairs
$smarty->append_by_ref("Name",$myname);
$smarty->append_by_ref("Address",$address);</programlisting>
</example>
</sect1>
<sect1 id="api.assign">
<title>assign</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>assign</function></funcdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
</funcprototype>
<funcprototype>
<funcdef>void <function>assign</function></funcdef>
<paramdef>string <parameter>varname</parameter></paramdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso <20> usado para fixar valores para o template. Voc<6F> pode
explicitamente passar pares de nomes/valores, ou um array associativo
contendo o par de nome/valor.
</para>
<example>
<title>assign</title>
<programlisting>
// passing name/value pairs
$smarty->assign("Name","Fred");
$smarty->assign("Address",$address);
// passing an associative array
$smarty->assign(array("city" => "Lincoln","state" => "Nebraska"));</programlisting>
</example>
</sect1>
<sect1 id="api.assign.by.ref">
<title>assign_by_ref</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>assign_by_ref</function></funcdef>
<paramdef>string <parameter>varname</parameter></paramdef>
<paramdef>mixed <parameter>var</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso <20> usado para fixar valores para o template por refer<65>ncia ao inv<6E>s de fazer uma c<>pia.
Veja o manual do PHP na parte sobre refer<65>ncia de vari<72>veis para uma explana<6E><61>o mais detalhada.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
Isso <20> usado para fixar valores para o template por refer<65>ncia.
Se voc<6F> fixar uma vari<72>vel por refer<65>ncia e ent<6E>o alterar o valor dela,
o valor fixado enxergar<61> o valor alterado tamb<6D>m.
Para objetos, assign_by_ref() tamb<6D>m restringe uma c<>pia de objetos fixados
em mem<65>ria.
Veja o manual do php em refereciando vari<72>veis para uma melhor explana<6E><61>o.
</para>
</note>
<example>
<title>assign_by_ref</title>
<programlisting>
// passing name/value pairs
$smarty->assign_by_ref("Name",$myname);
$smarty->assign_by_ref("Address",$address);</programlisting>
</example>
</sect1>
<sect1 id="api.clear.all.assign">
<title>clear_all_assign</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>clear_all_assign</function></funcdef>
<paramdef><parameter></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso limpa o valor de todas as vari<72>veis fixadas.
</para>
<example>
<title>clear_all_assign</title>
<programlisting>
// clear all assigned variables
$smarty->clear_all_assign();</programlisting>
</example>
</sect1>
<sect1 id="api.clear.all.cache">
<title>clear_all_cache</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>clear_all_cache</function></funcdef>
<paramdef>int <parameter>expire time</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso limpa completamente o cache de template. Como um par<61>metro
opcional, voc<6F> pode fornecer um ano m<>nimo em segundos
que o arquivo de cache deve ter antes deles serem apagados.
</para>
<example>
<title>clear_all_cache</title>
<programlisting>
// clear the entire cache
$smarty->clear_all_cache();</programlisting>
</example>
</sect1>
<sect1 id="api.clear.assign">
<title>clear_assign</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>clear_assign</function></funcdef>
<paramdef>string <parameter>var</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso limpa o valor de uma vari<72>vel fixada. Isso
pode ser um valor simples, ou um array de valores.
</para>
<example>
<title>clear_assign</title>
<programlisting>
// clear a single variable
$smarty->clear_assign("Name");
// clear multiple variables
$smarty->clear_assign(array("Name","Address","Zip"));</programlisting>
</example>
</sect1>
<sect1 id="api.clear.cache">
<title>clear_cache</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>clear_cache</function></funcdef>
<paramdef>string <parameter>template</parameter></paramdef>
<paramdef>string <parameter><optional>cache id</optional></parameter></paramdef>
<paramdef>string <parameter><optional>compile id</optional></parameter></paramdef>
<paramdef>int <parameter><optional>expire time</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso limpa o cache de um template espec<65>fico. Se voc<6F> tem
m<>ltiplos caches para este arquivo, voc<6F> limpa o cache
espec<65>fico fornecendo o cache id como o segundo par<61>metro.
Voc<6F> pode tamb<6D>m passar um compile id como um terceiro par<61>metro.
Voc<6F> pode "agrupar" templates juntos e ent<6E>o eles podem ser removidos
como um grupo. Veja o <link linkend="caching">caching section</link> para maiores informa<6D><61>es. Como um quarto
par<61>metro opcional, voc<6F> pode fornecer um ano m<>nimo em segundos
que o arquivo de cache deve
ter antes dele ser apagado.
</para>
<example>
<title>clear_cache</title>
<programlisting>
// clear the cache for a template
$smarty->clear_cache("index.tpl");
// clear the cache for a particular cache id in an multiple-cache template
$smarty->clear_cache("index.tpl","CACHEID");</programlisting>
</example>
</sect1>
<sect1 id="api.clear.compiled.tpl">
<title>clear_compiled_tpl</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>clear_compiled_tpl</function></funcdef>
<paramdef>string <parameter>tpl_file</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso limpa a vers<72>o compilada do recurso de template especificado,
ou todos os arquivos de templates compilados se nenhum for especificado.
Essa fun<75><6E>o <20> para uso avan<61>ado somente, n<>o normalmente necess<73>ria.
</para>
<example>
<title>clear_compiled_tpl</title>
<programlisting>
// clear a specific template resource
$smarty->clear_compiled_tpl("index.tpl");
// clear entire compile directory
$smarty->clear_compiled_tpl();</programlisting>
</example>
</sect1>
<sect1 id="api.clear.config">
<title>clear_config</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>clear_config</function></funcdef>
<paramdef>string <parameter><optional>var</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso limpa todas as vari<72>veis de configura<72><61>o fixadas. Se um nome de vari<72>vel
<09> fornecido, somente esta vari<72>vel <20> apagada.
</para>
<example>
<title>clear_config</title>
<programlisting>
// clear all assigned config variables.
$smarty->clear_config();
// clear one variable
$smarty->clear_config('foobar');</programlisting>
</example>
</sect1>
<sect1 id="api.config.load">
<title>config_load</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>config_load</function></funcdef>
<paramdef>string <parameter>file</parameter></paramdef>
<paramdef>string <parameter><optional>section</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso carrega o arquivo de configura<72><61>o de dados e fixa-o para o
template. Isso funciona id<69>ntico a fun<75><6E>o <link
linkend="language.function.config.load">
config_load</link>.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
<20> partir da Smarty 2.4.0, vari<72>veis de template fixadas s<>o
mantidas atrav<61>s de fetch() e display(). Vari<72>veis de configura<72><61>o carregadas
de config_load() s<>o sempre de escopo global. Arquivos de configura<72><61>o
tamb<6D>m s<>o compilados para execu<63><75>o r<>pida, e repeita o <link
linkend="variable.force.compile">force_compile</link> e <link
linkend="variable.compile.check">compile_check</link> par<61>metros de configura<72><61>o.
</para>
</note>
<example>
<title>config_load</title>
<programlisting>
// load config variables and assign them
$smarty->config_load('my.conf');
// load a section
$smarty->config_load('my.conf','foobar');</programlisting>
</example>
</sect1>
<sect1 id="api.display">
<title>display</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>display</function></funcdef>
<paramdef>string <parameter>template</parameter></paramdef>
<paramdef>string <parameter><optional>cache_id</optional></parameter></paramdef>
<paramdef>string <parameter><optional>compile_id</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso mostra o template. Fornecendo um v<>lido <link
linkend="template.resources">template resource</link>
tipo e path. Como um segundo par<61>metro opcional, voc<6F> pode passar
um cache id. Veja o <link linkend="caching">caching
section</link> para maiores informa<6D><61>es.
</para>
<para>
Como um terceiro par<61>metro opcional, voc<6F> pode passar um compile id.
Isso est<73> no evento que voc<6F> quer compilar diferentes vers<72>es do
mesmo template, como ter templates compilados separadamente para diferentes linguagens.
Outro uso para compile_id <20> quando voc<6F> usa mais do que um $template_dir
mas somente um $compile_dir. Seta um compile_id em separado para cada $template_dir,
de outra maneira templates com mesmo nome ir<69>o sobrescrever-se um ao outro.
Voc<6F> pode tamb<6D>m setar a vari<72>vel <link
linkend="variable.compile.id">$compile_id</link> ao inv<6E>s de
passar isso para cada chamada
de display().
</para>
<example>
<title>display</title>
<programlisting>
include("Smarty.class.php");
$smarty = new Smarty;
$smarty->caching = true;
// only do db calls if cache doesn't exist
if(!$smarty->is_cached("index.tpl"))
{
// dummy up some data
$address = "245 N 50th";
$db_data = array(
"City" => "Lincoln",
"State" => "Nebraska",
"Zip" = > "68502"
);
$smarty->assign("Name","Fred");
$smarty->assign("Address",$address);
$smarty->assign($db_data);
}
// display the output
$smarty->display("index.tpl");</programlisting>
</example>
<para>
Use a sintaxe para <link
linkend="template.resources">template resources</link> para
mostrar arquivos fora do $template_dir directory.
</para>
<example>
<title>Exemplos de recursos da fun<75><6E>o display</title>
<programlisting>
// absolute filepath
$smarty->display("/usr/local/include/templates/header.tpl");
// absolute filepath (same thing)
$smarty->display("file:/usr/local/include/templates/header.tpl");
// windows absolute filepath (MUST use "file:" prefix)
$smarty->display("file:C:/www/pub/templates/header.tpl");
// include from template resource named "db"
$smarty->display("db:header.tpl");</programlisting>
</example>
</sect1>
<sect1 id="api.fetch">
<title>fetch</title>
<funcsynopsis>
<funcprototype>
<funcdef>string <function>fetch</function></funcdef>
<paramdef>string <parameter>template</parameter></paramdef>
<paramdef>string <parameter><optional>cache_id</optional></parameter></paramdef>
<paramdef>string <parameter><optional>compile_id</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso retorna a sa<73>da do template ao inv<6E>s de mostr<74>-lo.
Fornecendo um tipo ou path v<>lido <link
linkend="template.resources">template resource</link>.
Como um segundo par<61>metro opcional, voc<6F> pode passar o cache id.
Veja o <link linkend="caching">caching
section</link> para maiores informa<6D><61>es.
</para>
<para>
Como um terceiro par<61>metro opcional, voc<6F> pode passar um compile id.
Isso est<73> no evento que voc<6F> quer compilar diferentes vers<72>es do
mesmo template, como ter templates compilados separadamente para
diferentes linguagens. Outro uso para compile_id <20> quando voc<6F>
usa mais do que um $template_dir mas somente um $compile_dir. Seta
um compile_id em separado para cada $template_dir, de outra maneira
templates com mesmo nome ir<69>o sobrescrever-se uns aos outros. Voc<6F>
pode tamb<6D>m setar a vari<72>vel <link
linkend="variable.compile.id">$compile_id</link> ao inv<6E>s
de pass<73>-la para cada chamada de fetch().
</para>
<example>
<title>fetch</title>
<programlisting>
include("Smarty.class.php");
$smarty = new Smarty;
$smarty->caching = true;
// only do db calls if cache doesn't exist
if(!$smarty->is_cached("index.tpl"))
{
// dummy up some data
$address = "245 N 50th";
$db_data = array(
"City" => "Lincoln",
"State" => "Nebraska",
"Zip" = > "68502"
);
$smarty->assign("Name","Fred");
$smarty->assign("Address",$address);
$smarty->assign($db_data);
}
// capture the output
$output = $smarty->fetch("index.tpl");
// do something with $output here
echo $output;</programlisting>
</example>
</sect1>
<sect1 id="api.get.config.vars">
<title>get_config_vars</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>get_config_vars</function></funcdef>
<paramdef>string <parameter><optional>varname</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso retorna o valor da vari<72>vel de configura<72><61>o dada.
Se nenhum par<61>metro <20> dado, um array de todas as vari<72>veis dos arquivos de configura<72><61>es <20> retornado.
</para>
<example>
<title>get_config_vars</title>
<programlisting>
// get loaded config template var 'foo'
$foo = $smarty->get_config_vars('foo');
// get all loaded config template vars
$config_vars = $smarty->get_config_vars();
// take a look at them
print_r($config_vars);</programlisting>
</example>
</sect1>
<sect1 id="api.get.registered.object">
<title>get_registered_object</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>get_registered_object</function></funcdef>
<paramdef>string <parameter>object_name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso retorna uma refer<65>ncia para um objeto registrado.
Isso <20> <20>til para dentro de uma fun<75><6E>o customizada quando voc<6F>
precisa acessar diretamente um objeto registrado.
</para>
<example>
<title>get_registered_object</title>
<programlisting>
function smarty_block_foo($params, &amp;$smarty) {
if (isset[$params['object']]) {
// get reference to registered object
$obj_ref =&amp; $smarty->&amp;get_registered_object($params['object']);
// use $obj_ref is now a reference to the object
}
}</programlisting>
</example>
</sect1>
<sect1 id="api.get.template.vars">
<title>get_template_vars</title>
<funcsynopsis>
<funcprototype>
<funcdef>array <function>get_template_vars</function></funcdef>
<paramdef>string <parameter><optional>varname</optional></parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso retorna o valor de uma vari<72>vel fixada. Se nenhum par<61>metro
<09> dado, um array de todas as vari<72>vels fixadas <20> retornado.
</para>
<example>
<title>get_template_vars</title>
<programlisting>
// get assigned template var 'foo'
$foo = $smarty->get_template_vars('foo');
// get all assigned template vars
$tpl_vars = $smarty->get_template_vars();
// take a look at them
print_r($tpl_vars);</programlisting>
</example>
</sect1>
<sect1 id="api.is.cached">
<title>is_cached</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>is_cached</function></funcdef>
<paramdef>string <parameter>template</parameter></paramdef>
<paramdef>[string <parameter>cache_id</parameter>]</paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso retorna true se h<> um cache v<>lido para esse template.
Isso somente funciona se <link
linkend="variable.caching">caching</link> est<73> setado para true.
</para>
<example>
<title>is_cached</title>
<programlisting>
$smarty->caching = true;
if(!$smarty->is_cached("index.tpl")) {
// do database calls, assign vars here
}
$smarty->display("index.tpl");</programlisting>
</example>
<para>
Voc<6F> pode tamb<6D>m passar um cache id como um segundo par<61>metro opcional
no caso voc<6F> quer m<>ltiplos caches para o template dado.
</para>
<example>
<title>is_cached with multiple-cache template</title>
<programlisting>
$smarty->caching = true;
if(!$smarty->is_cached("index.tpl","FrontPage")) {
// do database calls, assign vars here
}
$smarty->display("index.tpl","FrontPage");</programlisting>
</example>
</sect1>
<sect1 id="api.load.filter">
<title>load_filter</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>load_filter</function></funcdef>
<paramdef>string <parameter>type</parameter></paramdef>
<paramdef>string <parameter>name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Essa fun<75><6E>o pode ser usada para carregar um filtro de plugin. O primeiro
argumento especifica o tipo do filtro para carregar e pode ser um
dos seguintes: 'pre', 'post', ou 'output'. O segundo argumento
especifica o nome do filtro de plugin, por exemplo, 'trim'.
</para>
<example>
<title>Carregando filtros de plugins</title>
<programlisting>
$smarty->load_filter('pre', 'trim'); // load prefilter named 'trim'
$smarty->load_filter('pre', 'datefooter'); // load another prefilter named 'datefooter'
$smarty->load_filter('output', 'compress'); // load output filter named 'compress'</programlisting>
</example>
</sect1>
<sect1 id="api.register.block">
<title>register_block</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>register_block</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
<paramdef>mixed <parameter>impl</parameter></paramdef>
<paramdef>bool <parameter>cacheable</parameter></paramdef>
<paramdef>array or null <parameter>cache_attrs</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para registrar dinamicamente blocos de fun<75><6E>es de plugins.
Passe no bloco de nomes de fun<75><6E>o, seguido por uma chamada de fun<75><6E>o PHP
que implemente isso.
</para>
<para>
A chamada de uma fun<75><6E>o-php <parameter>impl</parameter> pode ser (a)
uma string contendo o nome da fun<75><6E>o ou (b) um array no formato
<literal>array(&amp;$object, $method)</literal> com
<literal>&amp;$object</literal> sendo uma refer<65>ncia para um
objeto e <literal>$method</literal> sendo uma string
contendo o nome do m<>todo ou (c) um array no formato
<literal>array(&amp;$class, $method)</literal> com
<literal>$class</literal> sendo um nome de classe e
<literal>$method</literal> sendo um
m<>todo desta classe.
</para>
<para>
<parameter>$cacheable</parameter> e <parameter>$cache_attrs</parameter> podem ser omitidos na maior parte dos casos. Veja <link linkend="caching.cacheable">Controlando modos de Sa<53>da de Cache dos Plugins</link> para obter informa<6D><61>es apropriadas.
</para>
<example>
<title>register_block</title>
<programlisting>
/* PHP */
$smarty->register_block("translate", "do_translation");
function do_translation ($params, $content, &amp;$smarty, &amp;$repeat) {
if (isset($content)) {
$lang = $params['lang'];
// do some translation with $content
return $translation;
}
}
{* template *}
{translate lang="br"}
Hello, world!
{/translate}</programlisting>
</example>
</sect1>
<sect1 id="api.register.compiler.function">
<title>register_compiler_function</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>register_compiler_function</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
<paramdef>mixed <parameter>impl</parameter></paramdef>
<paramdef>bool <parameter>cacheable</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para registrar dinamicamente uma fun<75><6E>o de plugin compilador.
Passe no nome da fun<75><6E>o compilador, seguido pela fun<75><6E>o
PHP que implemente isso.
</para>
<para>
A chamada para fun<75><6E>o-php <parameter>impl</parameter>
pode ser uma string contendo o nome da fun<75><6E>o ou (b) um array
no formato <literal>array(&amp;$object, $method)</literal> com
<literal>&amp;$object</literal> sendo uma refer<65>ncia para um
objeto e <literal>$method</literal> sendo uma string
contendo o nome do m<>todo ou (c) um array no formato
<literal>array(&amp;$class, $method)</literal> com
<literal>$class</literal> sendo um nome de classe e
<literal>$method</literal> sendo o m<>todo
desta classe.
</para>
<para>
<parameter>$cacheable</parameter> pode ser omitido na maioria
dos casos. Veja <link linkend="caching.cacheable">Controlando modos de Sa<53>da de Cache dos Plugins</link>
para obter informa<6D><61>es apropriadas.
</para>
</sect1>
<sect1 id="api.register.function">
<title>register_function</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>register_function</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
<paramdef>mixed <parameter>impl</parameter></paramdef>
<paramdef>bool <parameter>cacheable</parameter></paramdef>
<paramdef>array or null <parameter>cache_attrs</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para registrar fun<75><6E>es de plugins dinamicamente para o template.
Passe no template o nome da fun<75><6E>o,
seguido pelo nome da fun<75><6E>o PHP que implemente isso.
</para>
<para>
A chamada para fun<75><6E>o-php <parameter>impl</parameter> pode ser (a)
uma string contendo o nome da fun<75><6E>o ou (b) um array no formato
<literal>array(&amp;$object, $method)</literal> com
<literal>&amp;$object</literal> sendo uma refer<65>ncia para um
objeto e <literal>$method</literal> sendo uma string
contendo o nome do m<>todo ou (c) um array no formato
<literal>array(&amp;$class, $method)</literal> com
<literal>$class</literal> sendo um nome de classe e
<literal>$method</literal> sendo um m<>todo
desta classe.
</para>
<para>
<parameter>$cacheable</parameter> e <parameter>$cache_attrs</parameter> podem ser omitidos na maioria dos casos. Veja <link linkend="caching.cacheable">Controlando modos de Sa<53>da Cache dos Plugins</link> para obter informa<6D><61>es apropriadas.
</para>
<example>
<title>register_function</title>
<programlisting>
$smarty->register_function("date_now", "print_current_date");
function print_current_date ($params) {
extract($params);
if(empty($format))
$format="%b %e, %Y";
return strftime($format,time());
}
// agora voc<6F> pode usar isso no Smarty para mostrar a data atual: {date_now}
// ou, {date_now format="%Y/%m/%d"} para formatar isso.</programlisting>
</example>
</sect1>
<sect1 id="api.register.modifier">
<title>register_modifier</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>register_modifier</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
<paramdef>mixed <parameter>impl</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para modificar dinamicamente plugins registrados.
Passe no template o nome do modificador, seguido da fun<75><6E>o PHP
que implemente isso.
</para>
<para>
A chamada da fun<75><6E>o-php <parameter>impl</parameter>
pode ser (a) uma strin contendo o nome da fun<75><6E>o
ou (b) um array no formato
<literal>array(&amp;$object, $method)</literal> com
<literal>&amp;$object</literal> sendo uma refer<65>ncia para um
objeto e <literal>$method</literal> sendo uma string
contendo o nome do m<>todo ou (c) um array no formato
<literal>array(&amp;$class, $method)</literal> com
<literal>$class</literal> sendo um nome de classe e
<literal>$method</literal> sendo um m<>todo desta classe.
</para>
<example>
<title>register_modifier</title>
<programlisting>
// let's map PHP's stripslashes function to a Smarty modifier.
$smarty->register_modifier("sslash","stripslashes");
// now you can use {$var|sslash} to strip slashes from variables</programlisting>
</example>
</sect1>
<sect1 id="api.register.object">
<title>register_object</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>register_object</function></funcdef>
<paramdef>string <parameter>object_name</parameter></paramdef>
<paramdef>object <parameter>$object</parameter></paramdef>
<paramdef>array <parameter>allowed methods/properties</parameter></paramdef>
<paramdef>boolean <parameter>format</parameter></paramdef>
<paramdef>array <parameter>block methods</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Isso <20> para registrar um objeto para uso no template. Veja a
<link linkend="advanced.features.objects">se<73><65>o de objetos</link>
do manual para examplos.
</para>
</sect1>
<sect1 id="api.register.outputfilter">
<title>register_outputfilter</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>register_outputfilter</function></funcdef>
<paramdef>mixed <parameter>function</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para registrar dinamicamente filtros de sa<73>da para opera<72><61>es
na sa<73>da do template antes de mostr<74>-lo. Veja
<link linkend="advanced.features.outputfilters">Filtros de Sa<53>da de Templates</link>
para maiores informa<6D><61>es de como configurar uma
fun<75><6E>o de filtro de sa<73>da.
</para>
<para>
A chamada da fun<75><6E>o-php <parameter>function</parameter> pode
ser (a) uma string contendo um nome de fun<75><6E>o ou (b) um array no formato
<literal>array(&amp;$object, $method)</literal> com
<literal>&amp;$object</literal> sendo uma refer<65>ncia para um
objeto e <literal>$method</literal> sendo uma string
contendo o nome do m<>todo ou (c) um array no formato
<literal>array(&amp;$class, $method)</literal> com
<literal>$class</literal> sendo um nome de classe e
<literal>$method</literal> sendo um m<>todo
desta classe.
</para>
</sect1>
<sect1 id="api.register.postfilter">
<title>register_postfilter</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>register_postfilter</function></funcdef>
<paramdef>mixed <parameter>function</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para registrar dinamicamente p<>sfiltros para rodar templates
ap<61>s eles terem sido compilados. Veja
<link linkend="advanced.features.postfilters">p<>sfiltros de template</link> para
maiores informa<6D><61>es de como configurar fun<75><6E>es de p<>sfiltragem.
</para>
<para>
A chamada da fun<75><6E>o-php <parameter>function</parameter> pode
ser (a) uma string contendo um nome de fun<75><6E>o ou (b) um array no formato
<literal>array(&amp;$object, $method)</literal> com
<literal>&amp;$object</literal> sendo uma refer<65>ncia para um
objeto e <literal>$method</literal> sendo uma string
contendo o nome do m<>todo ou (c) um array no formato
<literal>array(&amp;$class, $method)</literal> com
<literal>$class</literal> sendo um nome de classe e
<literal>$method</literal> sendo um m<>todo
desta classe.
</para>
</sect1>
<sect1 id="api.register.prefilter">
<title>register_prefilter</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>register_prefilter</function></funcdef>
<paramdef>mixed <parameter>function</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para registrar pr<70>filtros dinamicamente para rodar
templates antes deles serem compilados. Veja <link
linkend="advanced.features.prefilters">template prefilters</link> para
maiores informa<6D><61>es de como configurar uma fun<75><6E>o de pr<70>filtragem.
</para>
<para>
A chamada da fun<75><6E>o-php <parameter>function</parameter> pode
ser (a) uma string contendo um nome de fun<75><6E>o ou (b) um array no formato
<literal>array(&amp;$object, $method)</literal> com
<literal>&amp;$object</literal> sendo uma refer<65>ncia para um
objeto e <literal>$method</literal> sendo uma string
contendo o nome do m<>todo ou (c) um array no formato
<literal>array(&amp;$class, $method)</literal> com
<literal>$class</literal> sendo um nome de classe e
<literal>$method</literal> sendo um m<>todo
desta classe.
</para>
</sect1>
<sect1 id="api.register.resource">
<title>register_resource</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>register_resource</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
<paramdef>array <parameter>resource_funcs</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para registrar dinamicamente um recurso de plugin com a Smarty.
Passe no nome o recurso e o array de fun<75><6E>es
PHP que implementam isso. Veja
<link linkend="template.resources">template resources</link>
para maiores informa<6D><61>es de como configurar uma fun<75><6E>o para retornar
templates.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
Um nome de recurso deve ter ao menos dois caracteres de comprimento.
Um caracter do nome de recurso ir<69> ser ignorado e usado como parte do
path do arquivo como, $smarty->display('c:/path/to/index.tpl');
</para>
</note>
<para>
A fun<75><6E>o-php-array <parameter>resource_funcs</parameter>
deve ter 4 ou 5 elementos. Com 4 elementos os elementos s<>o
as functions-callbacks para as respectivas fun<75><6E>es "source",
"timestamp", "secure" e "trusted" de recurso.
Com 5 elementos o primeiro elemento tem que ser um objeto por refer<65>ncia
ou um nome de classe do objeto ou uma classe implementando o recurso e os 4
elementos seguintes tem que ter os nomes de m<>todos
implementando "source", "timestamp",
"secure" e "trusted".
</para>
<example>
<title>register_resource</title>
<programlisting>
$smarty->register_resource("db", array("db_get_template",
"db_get_timestamp",
"db_get_secure",
"db_get_trusted"));</programlisting>
</example>
</sect1>
<sect1 id="api.trigger.error">
<title>trigger_error</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>trigger_error</function></funcdef>
<paramdef>string <parameter>error_msg</parameter></paramdef>
<paramdef>[int <parameter>level</parameter>]</paramdef>
</funcprototype>
</funcsynopsis>
<para>
Essa fun<75><6E>o pode ser usada para sa<73>da de uma mensagem de erro usando Smarty.
O par<61>metro <parameter>level</parameter> pode ser um dos valores usados
para a fun<75><6E>o de php trigger_error(), ex.: E_USER_NOTICE,
E_USER_WARNING, etc. Por padr<64>o <20> E_USER_WARNING.
</para>
</sect1>
<sect1 id="api.template.exists">
<title>template_exists</title>
<funcsynopsis>
<funcprototype>
<funcdef>bool <function>template_exists</function></funcdef>
<paramdef>string <parameter>template</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Essa fun<75><6E>o checa se o template especificado existe. Isso pode
aceitar um path para o template no filesystem ou um recurso de string
especificando o template.
</para>
</sect1>
<sect1 id="api.unregister.block">
<title>unregister_block</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>unregister_block</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para desregistrar dinamicamente um bloco de fun<75><6E>es de plugin.
Passe no bloco o nome da fun<75><6E>o.
</para>
</sect1>
<sect1 id="api.unregister.compiler.function">
<title>unregister_compiler_function</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>unregister_compiler_function</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use essa fun<75><6E>o para desregistrar uma fun<75><6E>o de compilador. Passe
o nome da fun<75><6E>o de compilador.
</para>
</sect1>
<sect1 id="api.unregister.function">
<title>unregister_function</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>unregister_function</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para desregistrar dinamicamente uma fun<75><6E>o de plugin do template.
Passe no template o nome da fun<75><6E>o.
</para>
<example>
<title>unregister_function</title>
<programlisting>
// n<>s n<>o queremos que designers template tenham acesso aos nossos arquivos do sistema
$smarty->unregister_function("fetch");</programlisting>
</example>
</sect1>
<sect1 id="api.unregister.modifier">
<title>unregister_modifier</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>unregister_modifier</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para desregistrar dincamimente um modificador de plugin.
Passe no template o nome do modificador.
</para>
<example>
<title>unregister_modifier</title>
<programlisting>
// n<>s n<>o queremos que designers de template usem strip tags para os elementos
$smarty->unregister_modifier("strip_tags");</programlisting>
</example>
</sect1>
<sect1 id="api.unregister.object">
<title>unregister_object</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>unregister_object</function></funcdef>
<paramdef>string <parameter>object_name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para desregistrar um objeto.
</para>
</sect1>
<sect1 id="api.unregister.outputfilter">
<title>unregister_outputfilter</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>unregister_outputfilter</function></funcdef>
<paramdef>string <parameter>function_name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para desregistrar dinamicamente um filtro de sa<73>da.
</para>
</sect1>
<sect1 id="api.unregister.postfilter">
<title>unregister_postfilter</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>unregister_postfilter</function></funcdef>
<paramdef>string <parameter>function_name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para dinamicamente desregistrar um p<>sfiltro.
</para>
</sect1>
<sect1 id="api.unregister.prefilter">
<title>unregister_prefilter</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>unregister_prefilter</function></funcdef>
<paramdef>string <parameter>function_name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para dinamicamente desregistrar um pr<70>filtro.
</para>
</sect1>
<sect1 id="api.unregister.resource">
<title>unregister_resource</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>unregister_resource</function></funcdef>
<paramdef>string <parameter>name</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Use isso para dinamicamente desregistrar um recurso de plugin.
Passe no par<61>metro nome o nome do recurso.
</para>
<example>
<title>unregister_resource</title>
<programlisting>
$smarty->unregister_resource("db");</programlisting>
</example>
</sect1>
</chapter>
<chapter id="caching">
<title>Caching</title>
<para>
Caching <20> usado para aumentar a velocidade de chamada para <link
linkend="api.display">display()</link> ou <link
linkend="api.fetch">fetch()</link> salvando isso num arquivo de sa<73>da. Se h<> uma vers<72>o
de cache dispon<6F>vel para a chamada, isso <20> mostrado ao inv<6E>s de regerar a sa<73>da de dados.
Caching pode fazer coisas tremendamente r<>pidas,
especialmente templates com longo tempo computacional. Desde a sa<73>da de dados do
display() ou fetch() est<73> em cache, um arquivo de cache poderia ser composto por
diversos arquivos de templates, arquivos de configura<72><61>o, etc.
</para>
<para>
Desde que templates sejam din<69>micos, <20> importante isso ter cuidado com
o que voc<6F> est<73> fazendo cache e por quanto tempo. Por exemplo, se voc<6F> est<73> mostrando
a p<>gina principal do seu website na qual as altera<72><61>es de conte<74>do s<>o muito frequentes,
isso funciona bem para cache dessa por uma hora ou mais. Um outro modo, se voc<6F> est<73>
mostrando uma p<>gina com um mapa do tempo contendo novas informa<6D><61>es por minuto, n<>o
faz sentido fazer cache nesta p<>gina.
</para>
<sect1 id="caching.setting.up">
<title>Configurando Caching</title>
<para>
A primeira coisa a fazer <20> habilitar o caching. Isso <20> feito pela configura<72><61>o <link
linkend="variable.caching">$caching</link> = true (or 1.)
</para>
<example>
<title>Habilitando Caching</title>
<programlisting>
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
$smarty->display('index.tpl');</programlisting>
</example>
<para>
Com caching habilitado, a chamada para a fun<75><6E>o display('index.tpl') ir<69> trazer
o template como usual, mas tamb<6D>m
salva uma c<>pia disso para o arquivo de sa<73>da (uma c<>pia de cache) in the <link linkend="variable.cache.dir">$cache_dir</link>.
Na pr<70>xima chamada de display('index.tpl'), a c<>pia em cache ser<65> usada
ao inv<6E>s de trazer novamente o template.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
Os arquivos no $cache_dir s<>o nomeados com similaridade ao nome do arquivo de template.
Embora eles terminem com a extens<6E>o ".php", eles n<>o s<>o realmente scripts execut<75>veis de php.
N<>o edite estes arquivos!
</para>
</note>
<para>
Cada p<>gina em cache tem um per<65>odo de tempo limitado determinado por <link
linkend="variable.cache.lifetime">$cache_lifetime</link>. O padr<64>o do valor <20>
3600 segundos, ou 1 hora. Ap<41>s o tempo expirar, o cache <20> regerado.
<09> poss<73>vel dar tempos individuais para caches com seu pr<70>prio tempo
de expira<72><61>o pela configura<72><61>o $caching = 2. Veja a documenta<74><61>o em <link
linkend="variable.cache.lifetime">$cache_lifetime</link> para detalhes.
</para>
<example>
<title>Configurando cache_lifetime por cache</title>
<programlisting>
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = 2; // lifetime is per cache
// set the cache_lifetime for index.tpl to 5 minutes
$smarty->cache_lifetime = 300;
$smarty->display('index.tpl');
// set the cache_lifetime for home.tpl to 1 hour
$smarty->cache_lifetime = 3600;
$smarty->display('home.tpl');
// NOTE: the following $cache_lifetime setting will not work when $caching = 2.
// The cache lifetime for home.tpl has already been set
// to 1 hour, and will no longer respect the value of $cache_lifetime.
// The home.tpl cache will still expire after 1 hour.
$smarty->cache_lifetime = 30; // 30 seconds
$smarty->display('home.tpl');</programlisting>
</example>
<para>
Se <link linkend="variable.compile.check">$compile_check</link> est<73> habilitado,
cada arquivo de template e arquivo de configura<72><61>o que est<73> envolvido com o arquivo em cache
<09> checado por modifica<63><61>es. Se algum destes arquivos foi modificado desde que o <20>ltimo cache
foi gerado, o cache <20> imediatamente regerado.
Isso <20> ligeiramente uma forma de optimiza<7A><61>o de performance de overhead, deixe $compile_check setado para false.
</para>
<example>
<title>Habilitando $compile_check</title>
<programlisting>
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
$smarty->compile_check = true;
$smarty->display('index.tpl');</programlisting>
</example>
<para>
Se <link linkend="variable.force.compile">$force_compile</link> est<73> habilitado,
os arquivos de cache ir<69>o sempre ser regerados. Isso <20> efetivamente desativar caching.
$force_compile <20> usualmente para prop<6F>sitos de debug somente, um caminho mais
eficiente de desativar caching <20> setar o <link
linkend="variable.caching">$caching</link> = false (ou 0.)
</para>
<para>
A fun<75><6E>o <link linkend="api.is.cached">is_cached()</link>
pode ser usada para testar se um template tem um cache v<>lido ou n<>o.
Se voc<6F> tem um template com cache que requer alguma coisa como um retorno do banco de dados,
voc<6F> pode usar isso para pular este processo.
</para>
<example>
<title>Usando is_cached()</title>
<programlisting>
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
if(!$smarty->is_cached('index.tpl')) {
// No cache available, do variable assignments here.
$contents = get_database_contents();
$smarty->assign($contents);
}
$smarty->display('index.tpl');</programlisting>
</example>
<para>
Voc<6F> pode deixar partes da sua p<>gina din<69>mica com a fun<75><6E>o de template <link
linkend="language.function.insert">insert</link>.
Vamos dizer que sua p<>gina inteira pode ter cache exceto para um banner que <20>
mostrado abaixo do lado direito da sua p<>gina. Usando uma fun<75><6E>o insert para o banner,
voc<6F> pode deixar esse elemento din<69>mico dentro do conte<74>do de cache. Veja a documenta<74><61>o
em <link linkend="language.function.insert">insert</link> para
detalhes e exemplos.
</para>
<para>
Voc<6F> pode limpar todos os arquivos de cache com a fun<75><6E>o <link
linkend="api.clear.all.cache">clear_all_cache()</link>, ou
arquivos de cache individuais (ou grupos) com a fun<75><6E>o <link
linkend="api.clear.cache">clear_cache()</link>.
</para>
<example>
<title>Limpando o cache</title>
<programlisting>
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
// clear out all cache files
$smarty->clear_all_cache();
// clear only cache for index.tpl
$smarty->clear_cache('index.tpl');
$smarty->display('index.tpl');</programlisting>
</example>
</sect1>
<sect1 id="caching.multiple.caches">
<title>Multiple Caches Per Page</title>
<para>
Voc<6F> pode ter m<>ltiplos arquivos de cache para uma simples chamada de display()
ou fetch(). Vamos dizer que uma chamada para display('index.tpl') deve ter v<>rios
conte<74>do de sa<73>da diferentes dependendo de alguma condi<64><69>o, e voc<6F> quer separar
os caches para cada um. Voc<6F> pode fazer isso passando um cache_id como um
segundo par<61>metro para a chamada da fun<75><6E>o.
</para>
<example>
<title>Passando um cache_id para display()</title>
<programlisting>
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
$my_cache_id = $_GET['article_id'];
$smarty->display('index.tpl',$my_cache_id);</programlisting>
</example>
<para>
Acima, n<>s estamos passando a vari<72>vel $my_cache_id para display() com o
cache_id. Para cada valor <20>nico de $my_cache_id, um cache em separado ir<69> ser
gerado para index.tpl. Nesse exemplo, "article_id" foi passado em URL e <20> usado
como o cache_id.
</para>
<note>
<title>Notas T<>cnicas</title>
<para>
Tenha muito cuidado quando passar valores do cliente (web brownser) dentro
da Smarty (ou alguma aplica<63><61>o PHP.) Embora o exemplo acima usando o article_id
vindo de uma URL pare<72>a f<>cil, isso poderia ter consequ<71>ncias ruins. O
cache_id <20> usado para criar um diret<65>rio no sistema de arquivos, ent<6E>o se o usu<73>rio
decidir passar um valor extremamente largo para article_id, ou escrever um script
que envia article_ids rand<6E>micos em um ritmo r<>pido, isso poderia possivelmente causar
problemas em n<>vel de servidor. Tenha certeza de limpar algum dado passado antes de usar isso. Nessa inst<73>ncia, talvez voc<6F>
saiba que o article_id tem um comprimento de 10 caracteres e isso <20> constitu<74>do somente
de alfa-num<75>ricos, e deve ser um
article_id v<>lido no database. Verifique isso!
</para>
</note>
<para>
Tenha certeza de passar o mesmo cache_id como o segundo
par<61>metro para <link linkend="api.is.cached">is_cached()</link> e
<link linkend="api.clear.cache">clear_cache()</link>.
</para>
<example>
<title>Passando um cache_id para is_cached()</title>
<programlisting>
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
$my_cache_id = $_GET['article_id'];
if(!$smarty->is_cached('index.tpl',$my_cache_id)) {
// No cache available, do variable assignments here.
$contents = get_database_contents();
$smarty->assign($contents);
}
$smarty->display('index.tpl',$my_cache_id);</programlisting>
</example>
<para>
Voc<6F> pode limpar todos os caches para um cache_id em particular passando
o primeiro par<61>metro null para clear_cache().
</para>
<example>
<title>Limpando todos os caches para um cache_id em particular</title>
<programlisting>
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
// clear all caches with "sports" as the cache_id
$smarty->clear_cache(null,"sports");
$smarty->display('index.tpl',"sports");</programlisting>
</example>
<para>
Desta maneira, voc<6F> pode "agrupar" seus
caches juntos dando-lhes o mesmo cache_id.
</para>
</sect1>
<sect1 id="caching.groups">
<title>Grupos de Cache</title>
<para>
Voc<6F> pode fazer agrupamentos mais elaborados configurando grupos de cache_id. Isso <20>
realizado pela separa<72><61>o de cada sub-grupo com uma barra vertical "|" no valor do
cache_id. Voc<6F> pode ter muitos sub-grupos com voc<6F> desejar.
</para>
<example>
<title>Grupos de cache_id</title>
<programlisting>
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
// clear all caches with "sports|basketball" as the first two cache_id groups
$smarty->clear_cache(null,"sports|basketball");
// clear all caches with "sports" as the first cache_id group. This would
// include "sports|basketball", or "sports|(anything)|(anything)|(anything)|..."
$smarty->clear_cache(null,"sports");
$smarty->display('index.tpl',"sports|basketball");</programlisting>
</example>
<note>
<title>Notas T<>cnicas</title>
<para>
O agrupamento de cache id N<>O use o path do template como alguma parte do cache_id.
Por exemplo, se voc<6F> tem display('themes/blue/index.tpl'), voc<6F> n<>o pode limpar o cache
para tudo que estiver sob o diret<65>rio "themes/blue". Se voc<6F> quiser fazer isso, voc<6F> deve
agrup<75>-los no cache_id, como display('themes/blue/index.tpl','themes|blue'); Ent<6E>o
voc<6F> pode limpar os caches para o
tema azul com with clear_cache(null,'themes|blue');
</para>
</note>
</sect1>
<sect1 id="caching.cacheable">
<title>Controlling Cacheability of Plugins' Output</title>
<para>
Desde Smarty-2.6.0 os caches de plugins pode ser declarados
ao registr<74>-los. O terceiro par<61>metro para register_block,
register_compiler_function e register_function <20> chamado
<parameter>$cacheable</parameter> e o padr<64>o para true que <20> tamb<6D>m
o comportamento de plugins na vers<72>o da Smarty antecessores <20> 2.6.0
</para>
<para>
Quando registrando um plugin com $cacheable=false o plugin <20> chamado todo o tempo na p<>gina que est<73> sendo mostrada, sempre se a p<>gina vier do cache. A fun<75><6E>o de plugin tem um comportamento levemente como uma fun<75><6E>o <link linkend="plugins.inserts">insert</link>.
</para>
<para>
Em contraste para <link linkend="language.function.insert">{insert}</link> o atributo para o plugin n<>o est<73> em cache por padr<64>o. Eles podem ser declarados para serem cacheados com o quarto par<61>metro <parameter>$cache_attrs</parameter>. <parameter>$cache_attrs</parameter> <20> um array de nomes de atributos que devem ser cacheados, ent<6E>o a fun<75><6E>o de plugin pega o valor como isso sendo o tempo que a p<>gina foi escrita para o cache todo o tempo isso <20> buscado do cache.
</para>
<example>
<title>Prevenindo uma sa<73>da de plugin de ser cacheada</title>
<programlisting>
index.php:
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
function remaining_seconds($params, &amp;$smarty) {
$remain = $params['endtime'] - time();
if ($remain >=0)
return $remain . " second(s)";
else
return "done";
}
$smarty->register_function('remaining', 'remaining_seconds', false, array('endtime'));
if (!$smarty->is_cached('index.tpl')) {
// fetch $obj from db and assign...
$smarty->assign_by_ref('obj', $obj);
}
$smarty->display('index.tpl');
index.tpl:
Tempo restante: {remain endtime=$obj->endtime}</programlisting>
<para>
O n<>mero de segundos at<61> que o endtime de $obj alcan<61>a altera<72><61>es em cada display de p<>gina, mesmo que a p<>gina esteja em cache. Desde o atributo endtime esteja em cache o objeto somente tem que ser puxado do banco de dados quando a p<>gina est<73> escrita para o cache mas n<>o em requisi<73><69>es subsequentes da p<>gina.
</para>
</example>
<example>
<title>Prevenindo uma passagem inteira do template para o cache</title>
<programlisting>
index.php:
require('Smarty.class.php');
$smarty = new Smarty;
$smarty->caching = true;
function smarty_block_dynamic($param, $content, &amp;$smarty) {
return $content;
}
$smarty->register_block('dynamic', 'smarty_block_dynamic', false);
$smarty->display('index.tpl');
index.tpl:
Page created: {"0"|date_format:"%D %H:%M:%S"}
{dynamic}
Now is: {"0"|date_format:"%D %H:%M:%S"}
... do other stuff ...
{/dynamic}</programlisting>
</example>
<para>
Quando recarregado a p<>gina que voc<6F> ir<69> notar que ambas as datas diferem. Uma <20> "din<69>mica" e uma <20> "est<73>tica". Voc<6F> pode fazer qualquer coisa entre as tags {dynamic}...{/dynamic} e ter certeza que isso n<>o ir<69> ficar em cache como o restante da p<>gina.
</para>
</sect1>
</chapter>
<chapter id="advanced.features">
<title>Advanced Features</title>
<sect1 id="advanced.features.objects">
<title>Objetos</title>
<para>
O Smarty permite acesso a objetos do PHP atrav<61>s de seus templates. H<> duas formas de acess<73>-los.
Uma forma <20> registrar objetos para o template, ent<6E>o os acessa via sintaxe similar a fun<75><6E>es
customiz<69>veis. A outra forma <20> atribuir objetos para os templates e acess<73>-los como se fossem
uma vari<72>vel atribu<62>da. O primeiro m<>todo tem uma sintaxe de template muito mais legal. E tamb<6D>m
mais segura, <20> medida que um objeto registrado pode ser restrito a certos m<>todos e
propriedades. Entretanto, um objeto registrado n<>o pode ser
posto em loop ou ser atribuido em arrays de
objetos, etc. O m<>todo que voc<6F> escolher ser<65> determinado pelas suas necessidades, mas use o
primeiro m<>todo se poss<73>vel para
manter um m<>nimo de sintaxe no template.
</para>
<para>
Se a seguran<61>a est<73> habilitada, nenhum dos m<>todos privados ou fun<75><6E>es podem acessados
(come<6D>ando com "_"). Se um m<>todo e propriedade de um mesmo nome existir, o m<>todo ser<65>
usado.
</para>
<para>
Voc<6F> pode restringir os m<>todos e propriedades que podem ser acessados listando os em um array
como o terceiro par<61>metro de registra<72><61>o.
</para>
<para>
Por defini<6E><69>o, par<61>metros passados para objetos atrav<61>s dos templates s<>o passados da mesma
forma que fun<75><6E>es customiz<69>veis os obt<62>m. Um array associativo <20> passado como o primeiro par<61>metro,
e o objeto smarty como o segundo. Se voc<6F> quer que os par<61>metros passados um de cada vez
por cada argumento como passagem de par<61>metro de objeto tradicional, defina o quarto par<61>metro
de registra<72><61>o para falso.
</para>
<para>
O quinto par<61>metro opcional s<> tem efeito com <parameter>format</parameter>
sendo <literal>true</literal> e cont<6E>m
uma lista de m<>tods de ob que seriam tratados como
blocos. Isso significa que estes m<>todos
tem uma tag de fechamento no template
(<literal>{foobar->meth2}...{/foobar->meth2}</literal>) e
os par<61>metros para os m<>todos tem a mesma sinopse como os par<61>metros para
block-function-plugins: Eles pegam 4 par<61>metros
<parameter>$params</parameter>,
<parameter>$content</parameter>,
<parameter>&amp;$smarty</parameter> e
<parameter>&amp;$repeat</parameter> e eles tamb<6D>m comportam-se como
block-function-plugins.
</para>
<example>
<title>usando um objeto registrado ou atribu<62>do</title>
<programlisting>
&lt;?php
// O objeto
class My_Object {
function meth1($params, &amp;$smarty_obj) {
return "this is my meth1";
}
}
$myobj = new My_Object;
// registrando o objeto (ser<65> por refer<65>ncia)
$smarty->register_object("foobar",$myobj);
// Se voc<6F> quer restringie acesso a certos m<>todos ou propriedades, liste-os
$smarty->register_object("foobar",$myobj,array('meth1','meth2','prop1'));
// Se voc<6F> quer usar o formato de par<61>metro de objeto tradicional, passe um booleano de false
$smarty->register_object("foobar",$myobj,null,false);
// Voc<6F> pode tamb<6D>m atribuir objetos. Atribua por refer<65>ncia quando poss<73>vel.
$smarty->assign_by_ref("myobj", $myobj);
$smarty->display("index.tpl");
?&gt;
TEMPLATE:
{* accessa nosso objeto registrado *}
{foobar->meth1 p1="foo" p2=$bar}
{* voc<6F> pode tamb<6D>m atribuir a sa<73>da *}
{foobar->meth1 p1="foo" p2=$bar assign="output"}
the output was {$output}
{* acessa nosso objeto atribu<62>do *}
{$myobj->meth1("foo",$bar)}</programlisting>
</example>
</sect1>
<sect1 id="advanced.features.prefilters">
<title>Prefilters</title>
<para>
Os prefilters de Template s<>o fun<75><6E>es de PHP nas quais seus templates s<>o rodados
antes de serem compilados. Isto <20> bom para preprocessamento de seus templates para remover
coment<6E>rios indesejados, mantendo o olho no que as pessoas est<73>o colocando nos seus templates,
etc. Prefilters podem ser ou <link linkend="api.register.prefilter">registrado</link>
ou carregado do diret<65>rio de plugins usando a fun<75><6E>o
<link linkend="api.load.filter">load_filter()</link>
ou pela configura<72><61>o da vari<72>vel
<link linkend="variable.autoload.filters">$autoload_filters</link>.
O Smarty passar<61> o c<>digo fonte do template como o
primeiro argumeto, e espera a fun<75><6E>o retornar
o c<>digo fonte do template resultante.
</para>
<example>
<title>Usando um prefilter de template</title>
<programlisting>
&lt;?php
// Ponha isto em sua aplica<63><61>o
function remove_dw_comments($tpl_source, &amp;$smarty)
{
return preg_replace("/&lt;!--#.*--&gt;/U","",$tpl_source);
}
// registrar o prefilter
$smarty->register_prefilter("remove_dw_comments");
$smarty->display("index.tpl");
?&gt;
{* Smarty template index.tpl *}
&lt;!--# esta linha ser<65> removida pelo prefilter --&gt;</programlisting>
</example>
</sect1>
<sect1 id="advanced.features.postfilters">
<title>Postfilters</title>
<para>
Os postfilters de template s<>o fun<75><6E>es de PHP nas quais seus templates s<>o rodados
imediatamente depois de serem compilados. Os postfilters podem ser ou
<link linkend="api.register.postfilter">registrado</link>carrgados do diret<65>rio de
plugins usando a fun<75><6E>o
<link linkend="api.load.filter">load_filter()</link> ou pela
vari<72>vel de configura<72><61>o
<link linkend="variable.autoload.filters">$autoload_filters</link>.
O Smarty passar<61> o c<>digo fonte do template compilado
como o primeiro argumento, e espera
a fun<75><6E>o retornar o resultado do processamento.
</para>
<example>
<title>usando um postfilter de template</title>
<programlisting>
&lt;?php
// ponha isto em sua aplica<63><61>o
function add_header_comment($tpl_source, &amp;$smarty)
{
return "&lt;?php echo \"&lt;!-- Created by Smarty! --&gt;\n\" ?&gt;\n".$tpl_source;
}
// registra o postfilter
$smarty->register_postfilter("add_header_comment");
$smarty->display("index.tpl");
?&gt;
{* compiled Smarty template index.tpl *}
&lt;!-- Created by Smarty! --&gt;
{* rest of template content... *}</programlisting>
</example>
</sect1>
<sect1 id="advanced.features.outputfilters">
<title>Output Filters (Filtros de Sa<53>da)</title>
<para>
Quando o template <20> invocado via display() ou fetch(), sua sa<73>da pode ser enviada
atrav<61>s de um ou mais filtros de sa<73>da. Estes diferem dos postfilters porque postfilters
operam em templates compilados antes de serem salvos para o disco, e os filtros de sa<73>da
operam na sa<73>da do template quando
ele <20> executado.
</para>
<para>
Filtros de Sa<53>da podem ser ou
<link linkend="api.register.outputfilter">registrado</link> ou carregado
do diret<65>rio de plugins usando a fun<75><6E>o
<link linkend="api.load.filter">load_filter()</link> ou configurando a vari<72>vel
<link linkend="variable.autoload.filters">$autoload_filters</link>.
O Smarty passar<61> a sa<73>da como o primeiro argumento,
e espera a fun<75><6E>o retornar o resultado
do processamento.
</para>
<example>
<title>usando um filtro de sa<73>da de template</title>
<programlisting>
&lt;?php
// ponha isto em sua aplica<63><61>o
function protect_email($tpl_output, &amp;$smarty)
{
$tpl_output =
preg_replace('!(\S+)@([a-zA-Z0-9\.\-]+\.([a-zA-Z]{2,3}|[0-9]{1,3}))!',
'$1%40$2', $tpl_output);
return $tpl_output;
}
// registra o outputfilter
$smarty->register_outputfilter("protect_email");
$smarty->display("index.tpl");
// agora qualquer ocorr<72>ncia de um endere<72>o de email na sa<73>da do template ter<65> uma
// simples prote<74><65>o contra spambots
?&gt;</programlisting>
</example>
</sect1>
<sect1 id="section.template.cache.handler.func">
<title>Fun<75><6E>o Manipuladora de Cache</title>
<para>
Como uma alternativa ao uso do mecanismo de caching padr<64>o baseado em arquivo, voc<6F> pode
especificar uma fun<75><6E>o de manipula<6C><61>o de cache customizada que ser<65> usada para ler, escrever
e limpar arquivos de cache.
</para>
<para>
Crie uma fun<75><6E>o em sua aplica<63><61>o que o Smarty usar<61> como um manipulador de cache. Defina o
nome dela na vari<72>vel de classe
<link linkend="variable.cache.handler.func">$cache_handler_func</link>.
O Smarty agora usar<61> esta para manipular dados no cache. O primeiro argumento <20> a a<><61>o,
que <20> um desses 'read', 'write' e 'clear'. O segundo par<61>metro <20> o objeto do Smarty. O
terceiro par<61>metro <20> o conte<74>do que est<73> no cache.
No write, o Smarty passa o conte<74>do em
cache nestes par<61>metros. No 'read', o Smarty espera sua fun<75><6E>o aceitar este par<61>metro por
refer<65>ncia e preenche ele com os dados em cache. No 'clear', passa uma vari<72>vel simulacra aqui
visto que ela n<>o <20> usada. O quarto par<61>metro
<20> o nome do arquivo de template (necess<73>rio para
ler/escrever), o quinto par<61>metro <20> a cache_id (opcional),
e o sexto <20> a compile_id (opcional).
</para>
<para>
Note que: O <20>ltimo par<61>metro ($exp_time)foi adicionado no Smarty-2.6.0.
</para>
<example>
<title>exemplo usando MySQL como uma fonte de cache</title>
<programlisting>
&lt;?php
/*
exemplo de uso:
include('Smarty.class.php');
include('mysql_cache_handler.php');
$smarty = new Smarty;
$smarty-&gt;cache_handler_func = 'mysql_cache_handler';
$smarty-&gt;display('index.tpl');
mysql database is expected in this format:
create database SMARTY_CACHE;
create table CACHE_PAGES(
CacheID char(32) PRIMARY KEY,
CacheContents MEDIUMTEXT NOT NULL
);
*/
function mysql_cache_handler($action, &amp;$smarty_obj, &amp;$cache_content, $tpl_file=null, $cache_id=null, $compile_id=null, $exp_time=null)
{
// set db host, user and pass here
$db_host = 'localhost';
$db_user = 'myuser';
$db_pass = 'mypass';
$db_name = 'SMARTY_CACHE';
$use_gzip = false;
// cria um cache id unico
$CacheID = md5($tpl_file.$cache_id.$compile_id);
if(! $link = mysql_pconnect($db_host, $db_user, $db_pass)) {
$smarty_obj-&gt;_trigger_error_msg("cache_handler: could not connect to database");
return false;
}
mysql_select_db($db_name);
switch ($action) {
case 'read':
// save cache to database
$results = mysql_query("select CacheContents from CACHE_PAGES where CacheID='$CacheID'");
if(!$results) {
$smarty_obj-&gt;_trigger_error_msg("cache_handler: query failed.");
}
$row = mysql_fetch_array($results,MYSQL_ASSOC);
if($use_gzip &amp;&amp; function_exists("gzuncompress")) {
$cache_contents = gzuncompress($row["CacheContents"]);
} else {
$cache_contents = $row["CacheContents"];
}
$return = $results;
break;
case 'write':
// save cache to database
if($use_gzip &amp;&amp; function_exists("gzcompress")) {
// compress the contents for storage efficiency
$contents = gzcompress($cache_content);
} else {
$contents = $cache_content;
}
$results = mysql_query("replace into CACHE_PAGES values(
'$CacheID',
'".addslashes($contents)."')
");
if(!$results) {
$smarty_obj-&gt;_trigger_error_msg("cache_handler: query failed.");
}
$return = $results;
break;
case 'clear':
// clear cache info
if(empty($cache_id) &amp;&amp; empty($compile_id) &amp;&amp; empty($tpl_file)) {
// clear them all
$results = mysql_query("delete from CACHE_PAGES");
} else {
$results = mysql_query("delete from CACHE_PAGES where CacheID='$CacheID'");
}
if(!$results) {
$smarty_obj-&gt;_trigger_error_msg("cache_handler: query failed.");
}
$return = $results;
break;
default:
// error, unknown action
$smarty_obj-&gt;_trigger_error_msg("cache_handler: unknown action \"$action\"");
$return = false;
break;
}
mysql_close($link);
return $return;
}
?&gt;</programlisting>
</example>
</sect1>
<sect1 id="template.resources">
<title>Recursos (Resources)</title>
<para>
Os templates podem vir de uma variedade de fontes. Quando voc<6F> exibe (display) ou
busca (fetch) um template, ou inclui um template de dentro de outro template, voc<6F>
fornece um tipo de recurso, seguido pelo
caminho e nome do template apropriado. Se um
recurso n<>o <20> dado explicitamente o valor de
<link linkend="variable.default.resource.type">$default_resource_type</link> <20> assumido.
</para>
<sect2 id="templates.from.template.dir">
<title>Templates partindo do $template_dir</title>
<para>
Templates a partir do $template_dir n<>o exigem um recurso de template,
apesar de voc<6F> usar o arquivo: resource for consistancy.
Apenas forne<6E>a o caminho para o template que voc<6F> quer usar em rela<6C><61>o ao diret<65>rio
root $template_dir.
</para>
<example>
<title>Usando templates partindo do $template_dir</title>
<programlisting>
// from PHP script
$smarty->display("index.tpl");
$smarty->display("admin/menu.tpl");
$smarty->display("file:admin/menu.tpl"); // Igual ao de cima
{* de dentro do template do Smarty *}
{include file="index.tpl"}
{include file="file:index.tpl"} {* igual ao de cima *}</programlisting>
</example>
</sect2>
<sect2 id="templates.from.any.dir">
<title>Templates partindo de qualquer diret<65>rio</title>
<para>
Os Templates de fora do $template_dir exigem o arquivo:
tipo de recurso do template,
seguido pelo caminho absoluto e nome do template.
</para>
<example>
<title>usando templates partindo de qualquer diret<65>rio</title>
<programlisting>
// de dentro do script PHP
$smarty->display("file:/export/templates/index.tpl");
$smarty->display("file:/path/to/my/templates/menu.tpl");
{* de dentro do template do Smarty *}
{include file="file:/usr/local/share/templates/navigation.tpl"}</programlisting>
</example>
<sect3>
<title>Caminhos de arquivos do Windows</title>
<para>
Se voc<6F> est<73> usando uma m<>quina windows, caminhos de arquivos normalmente incluem uma letra
do drive (C:) no come<6D>o do nome do caminho.
Esteja certo de usar "file:" no caminho para
evitar conflitos de nome e obter os resultados desejados.
</para>
<example>
<title>usando templates com caminhos de arquivo do windows</title>
<programlisting>
// de dentro do script PHP
$smarty->display("file:C:/export/templates/index.tpl");
$smarty->display("file:F:/path/to/my/templates/menu.tpl");
{* de dentro do template do Smarty *}
{include file="file:D:/usr/local/share/templates/navigation.tpl"}</programlisting>
</example>
</sect3>
</sect2>
<sect2 id="templates.from.elsewhere">
<title>Templates partindo de outras fontes</title>
<para>
Voc<6F> pode resgatar templates usando qualquer fonte poss<73>vel de voc<6F> acessar com PHP: banco
de dados, sockets, LDAP, e assim por diante.
Voc<6F> faz isto escrevendo as fun<75><6E>es de plugin
de recurso e registrando elas com o Smarty.
</para>
<para>
Veja a se<73><65>o <link linkend="plugins.resources">plugins de recurso</link>
para mais informa<6D><61>o sobre as fun<75><6E>es
que voc<6F> deve fornecer.
</para>
<note>
<para>
Note que voc<6F> pode ativar manualmente o recurso de <literal>arquivo</literal> embutido, mas n<>o pode fornecer um recurso que busca templates a partir do sistema de arquivos de alguma outra forma registrando sob um outro nome de recurso.
<literal>file</literal> resource, but you can provide a resource
that fetches templates from the file system in some other way by
registering under another resource name.
</para>
</note>
<example>
<title>usando recursos customiz<69>veis</title>
<programlisting>
// no script PHP
// ponha estas fun<75><6E>es em algum lugar de sua aplica<63><61>o
function db_get_template ($tpl_name, &amp;$tpl_source, &amp;$smarty_obj)
{
// fa<66>a o banco de dados chamar aqui para buscar o seu template,
// preenchendo o $tpl_source
$sql = new SQL;
$sql->query("select tpl_source
from my_table
where tpl_name='$tpl_name'");
if ($sql->num_rows) {
$tpl_source = $sql->record['tpl_source'];
return true;
} else {
return false;
}
}
function db_get_timestamp($tpl_name, &amp;$tpl_timestamp, &amp;$smarty_obj)
{
// fa<66>a o banco de dados chamar daqui para preencher a $tpl_timestamp.
$sql = new SQL;
$sql->query("select tpl_timestamp
from my_table
where tpl_name='$tpl_name'");
if ($sql->num_rows) {
$tpl_timestamp = $sql->record['tpl_timestamp'];
return true;
} else {
return false;
}
}
function db_get_secure($tpl_name, &amp;$smarty_obj)
{
// assume-se que todos os templates s<>o seguros
return true;
}
function db_get_trusted($tpl_name, &amp;$smarty_obj)
{
// n<>o usado para templates
}
// registrar o nome de recurso "db"
$smarty->register_resource("db", array("db_get_template",
"db_get_timestamp",
"db_get_secure",
"db_get_trusted"));
// usando o recurso a partir do script PHP
$smarty->display("db:index.tpl");
{* usando o recurso de dentro do template do Smarty *}
{include file="db:/extras/navigation.tpl"}</programlisting>
</example>
</sect2>
<sect2 id="default.template.handler.function">
<title>Fun<75><6E>o Manipuladora de Template Padr<64>o</title>
<para>
Voc<6F> pode especificar a fun<75><6E>o que <20> usada para devolver o conte<74>do do template no evento
em que o template n<>o pode ser devolvido de seu recurso. Um uso disto <20> para criar templates
que n<>o existem "on-the-fly"
(templates cujo conte<74>do flutua muito, bastante vari<72>vel).
</para>
<example>
<title>usando a fun<75><6E>o manipuladora de template padr<64>o</title>
<programlisting>
&lt;?php
// ponha esta fun<75><6E>o em algum lugar de sua aplica<63><61>o
function make_template ($resource_type, $resource_name, &amp;$template_source, &amp;$template_timestamp, &amp;$smarty_obj)
{
if( $resource_type == 'file' ) {
if ( ! is_readable ( $resource_name )) {
// cria um arquivo de template, retorna o conte<74>do.
$template_source = "This is a new template.";
$template_timestamp = time();
$smarty_obj->_write_file($resource_name,$template_source);
return true;
}
} else {
// n<>o <20> arquivo
return false;
}
}
// defina a manipuladora padr<64>o
$smarty->default_template_handler_func = 'make_template';
?&gt;</programlisting>
</example>
</sect2>
</sect1>
</chapter>
<chapter id="plugins">
<title>Extendendo a Smarty com Plugins</title>
<para>
A Vers<72>o 2.0 introduziu a arquitetura de plugin que <20> usada para quase todas as
funcionalidades customiz<69>veis da Smarty. Isto inclui:
<itemizedlist spacing="compact">
<listitem><simpara>fun<75><6E>es</simpara></listitem>
<listitem><simpara>modificadores</simpara></listitem>
<listitem><simpara>fun<75><6E>es de bloco</simpara></listitem>
<listitem><simpara>fun<75><6E>es de compilador</simpara></listitem>
<listitem><simpara>prefiltros</simpara></listitem>
<listitem><simpara>posfiltros</simpara></listitem>
<listitem><simpara>filtros de sa<73>da</simpara></listitem>
<listitem><simpara>recursos</simpara></listitem>
<listitem><simpara>inserir</simpara></listitem>
</itemizedlist>
Com a exce<63><65>o de recursos, a compatibilidade com a forma antiga de fun<75><6E>es de
manipulador de registro via register_* API <20> preservada. Se voc<6F> n<>o usou o API mas no lugar disso
modificou as vari<72>veis de classe <literal>$custom_funcs</literal>, <literal>$custom_mods</literal>, e
outras diretamente, ent<6E>o voc<6F> vai
precisar ajustar seus scripts para ou usar API ou converter suas
funcionalidade customizadas em plugins.
</para>
<sect1>
<title>Como os Plugins Funcionam</title>
<para>
Plugins s<>o sempre lidos quando requisitados. Apenas os modificadores espec<65>ficos,
fun<75><6E>es, recursos, etc convocados em scripts de template ser<65>o lidos. Al<41>m disso, cada plugin
<20> lido apenas uma vez, mesmo se voc<6F> tem v<>rias inst<73>ncias diferentes da Smarty rodando na mesma
requisi<73><69>o.
</para>
<para>
Pre/posfiltros e filtros de sa<73>da s<>o uma parte de um caso especial. Visto que eles n<>o s<>o mencionados
nos templates, eles devem ser registrados ou lidos explicitamente via fun<75><6E>es de API antes do template
ser processado.
A ordem em que multiplos filtros do mesmo
tipo s<>o executados dependem da ordem em que eles s<>o registrados ou lidos.
</para>
<para>
O <link linkend="variable.plugins.dir">diret<65>rio de plugins</link>
pode ser uma string contendo um caminho ou um array
contendo multiplos caminhos. Para instalar um plugin,
simplesmente coloque-o em um dos diret<65>rios e a Smarty ir<69> us<75>-lo automaticamente.
</para>
</sect1>
<sect1 id="plugins.naming.conventions">
<title>Conven<65><6E>es de Apar<61>ncia</title>
<para>
Arquivos e fun<75><6E>es de Plugin devem seguir uma conven<65><6E>o de apar<61>ncia muito espec<65>fica
a fim de ser localizada pela Smarty.
</para>
<para>
Os arquivos de plugin devem ser nomeados da sequinte forma:
<blockquote>
<para>
<filename>
<replaceable>tipo</replaceable>.<replaceable>nome</replaceable>.php
</filename>
</para>
</blockquote>
</para>
<para>
Onde <literal>tipo</literal> <20> um dos seguintes tipos de plugin:
<itemizedlist spacing="compact">
<listitem><simpara>function</simpara></listitem>
<listitem><simpara>modifier</simpara></listitem>
<listitem><simpara>block</simpara></listitem>
<listitem><simpara>compiler</simpara></listitem>
<listitem><simpara>prefilter</simpara></listitem>
<listitem><simpara>postfilter</simpara></listitem>
<listitem><simpara>outputfilter</simpara></listitem>
<listitem><simpara>resource</simpara></listitem>
<listitem><simpara>insert</simpara></listitem>
</itemizedlist>
</para>
<para>
E <literal>nome</literal> seria um identificador v<>lido (letras,
n<>meros, e underscores apenas).
</para>
<para>
Alguns exemplos: <literal>function.html_select_date.php</literal>,
<literal>resource.db.php</literal>,
<literal>modifier.spacify.php</literal>.
</para>
<para>
As fun<75><6E>es de plugin dentro dos arquivos do plugin devem ser nomeadas da seguinte forma:
<blockquote>
<para>
<function>smarty_<replaceable>tipo</replaceable>_<replaceable>nome</replaceable></function>
</para>
</blockquote>
</para>
<para>
O significado de <literal>tipo</literal> e
<literal>nome</literal> s<>o os mesmos de antes.
</para>
<para>
A Smarty mostrar<61> mensagens de erro apropriadas se o arquivo de plugins que <20> necess<73>rio n<>o <20> encontrado,
ou se o arquivo ou a fun<75><6E>o de plugin
est<73>o nomeadas inadequadamente.
</para>
</sect1>
<sect1 id="plugins.writing">
<title>Escrevendo Plugins</title>
<para>
Os Plugins podem ser ou lidos pela Smarty automaticamente do sistema de arquivos ou eles podem
ser registrados no tempo de execu<63><75>o via uma das fun<75><6E>es
de API register_* . Eles podem tamb<6D>m ser
com o uso da fun<75><6E>o API unregister_* .
</para>
<para>
Para os plugins que s<>o registrados no tempo de execu<63><75>o, o nome da(s) fun<75><6E>o(<28>es) de plugin
n<>o t<>m que seguir a conven<65><6E>o de apar<61>ncia.
</para>
<para>
Se um plugin depende de alguma funcionalidade fornecida por um outro plugin (como <20> o caso com alguns
plugins embutidos com a Smarty),
ent<6E>o a forma apropriada para ler o plugin necess<73>rio <20> esta:
</para>
<programlisting>
require_once $smarty->_get_plugin_filepath('function', 'html_options');</programlisting>
<para>
Como uma regra geral, o objeto da Smarty <20> sempre passado para os plugins como o <20>ltimo par<61>metro
(com duas exce<63><65>es: modificadores n<>o passam o objeto da Smarty em tudo e blocks passam
<parameter>&amp;$repeat</parameter> depois do objeto da Smarty
para manter compatibilidade a antigas
vers<72>es da Smarty).
</para>
</sect1>
<sect1 id="plugins.functions"><title>Fun<75><6E>es de Template</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>smarty_function_<replaceable>name</replaceable></function></funcdef>
<paramdef>array <parameter>$params</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Todos os atributos passados para as fun<75><6E>es de template a
partir do template est<73>o contidas em
<parameter>$params</parameter> como um array associativo. Ou acessa esses valores
diretamente i.e <varname>$params['start']</varname> ou usa
<varname>extract($params)</varname> para
import<72>-los para dentro da tabela s<>mbolo.
</para>
<para>
A sa<73>da (valor de retorno) da fun<75><6E>o ser<65> substitu<74>da no lugar da tag da fun<75><6E>o no template
(a fun<75><6E>o <function>fetch</function>, por exemplo). Alternativamente, a fun<75><6E>o pode simplesmente executar
alguma outra tarefa sem ter alguma sa<73>da
(a fun<75><6E>o <function>assign</function>).
</para>
<para>
Se a fun<75><6E>o precisa passar valores a algumas vari<72>veis para o template ou utilizar alguma outra funcionalidade
fornecida com a Smarty, ela pode usar
o objeto <parameter>$smarty</parameter> fornecido para fazer isso.
</para>
<para>
Veja tamb<6D>m:
<link linkend="api.register.function">register_function()</link>,
<link linkend="api.unregister.function">unregister_function()</link>.
</para>
<para>
<example>
<title>fun<75><6E>o de plugin com sa<73>da</title>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: function.eightball.php
* Type: function
* Name: eightball
* Purpose: outputs a random magic answer
* -------------------------------------------------------------
*/
function smarty_function_eightball($params, &amp;$smarty)
{
$answers = array('Yes',
'No',
'No way',
'Outlook not so good',
'Ask again soon',
'Maybe in your reality');
$result = array_rand($answers);
return $answers[$result];
}
?&gt;</programlisting>
</example>
</para>
<para>
que pode ser usada no template da seguinte forma:
</para>
<programlisting>
Pergunta: N<>s sempre teremos tempo para viajar?
Resposta: {eightball}.</programlisting>
<para>
<example>
<title>fun<75><6E>o de plugin sem sa<73>da</title>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: function.assign.php
* Type: function
* Name: assign
* Purpose: assign a value to a template variable
* -------------------------------------------------------------
*/
function smarty_function_assign($params, &amp;$smarty)
{
extract($params);
if (empty($var)) {
$smarty->trigger_error("assign: missing 'var' parameter");
return;
}
if (!in_array('value', array_keys($params))) {
$smarty->trigger_error("assign: missing 'value' parameter");
return;
}
$smarty->assign($var, $value);
}
?&gt;</programlisting>
</example>
</para>
</sect1>
<sect1 id="plugins.modifiers"><title>Modifiers</title>
<para>
Modificadores s<>o fun<75><6E>es que s<>o aplicadas a uma vari<72>vel no template antes dela ser mostrada
ou usada em algum outro contexto.
Modificadores podem ser encadeados juntos.
</para>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>smarty_modifier_<replaceable>name</replaceable></function></funcdef>
<paramdef>mixed <parameter>$value</parameter></paramdef>
<paramdef>[mixed <parameter>$param1</parameter>, ...]</paramdef>
</funcprototype>
</funcsynopsis>
<para>
O primeiro par<61>metro para o plugin midificador <20> o valor em que o modificador <20> suposto
operar. O resto dos par<61>metros podem ser opcionais,
dependendo de qual tipo de opera<72><61>o <20> para
ser executada.
</para>
<para>
O modificador deve retornar o resultado de seu processamento.
</para>
<para>
Veja tamb<6D>m:
<link linkend="api.register.modifier">register_modifier()</link>,
<link linkend="api.unregister.modifier">unregister_modifier()</link>.
</para>
<example>
<title>Plugin modificador simples</title>
<para>
Este plugin basiamente <20> um alias de uma
fun<75><6E>o do PHP. Ele n<>o tem nenhum par<61>metro adicional.
</para>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: modifier.capitalize.php
* Type: modifier
* Name: capitalize
* Purpose: capitalize words in the string
* -------------------------------------------------------------
*/
function smarty_modifier_capitalize($string)
{
return ucwords($string);
}
?&gt;</programlisting>
</example>
<para></para>
<example>
<title>Plugin modificador mais complexo</title>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: modifier.truncate.php
* Type: modifier
* Name: truncate
* Purpose: Truncate a string to a certain length if necessary,
* optionally splitting in the middle of a word, and
* appending the $etc string.
* -------------------------------------------------------------
*/
function smarty_modifier_truncate($string, $length = 80, $etc = '...',
$break_words = false)
{
if ($length == 0)
return '';
if (strlen($string) > $length) {
$length -= strlen($etc);
$fragment = substr($string, 0, $length+1);
if ($break_words)
$fragment = substr($fragment, 0, -1);
else
$fragment = preg_replace('/\s+(\S+)?$/', '', $fragment);
return $fragment.$etc;
} else
return $string;
}
?&gt;</programlisting>
</example>
</sect1>
<sect1 id="plugins.block.functions"><title>Block Functions</title>
<funcsynopsis>
<funcprototype>
<funcdef>void <function>smarty_block_<replaceable>name</replaceable></function></funcdef>
<paramdef>array <parameter>$params</parameter></paramdef>
<paramdef>mixed <parameter>$content</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Fun<75><6E>es de Block s<>o fun<75><6E>es da forma: {func} .. {/func}. Em outras palavras, ele enclausura
um bloco de template e opera no conte<74>do deste bloco. Fun<75><6E>es de Block tem preced<65>ncia sobre
fun<75><6E>es customizadas com mesmo nome,
assim, voc<6F> n<>o pode ter ambas, fun<75><6E>o customiz<69>vel {func} e
fun<75><6E>o de Bloco {func} .. {/func}.
</para>
<para>
Por defini<6E><69>o a implementa<74><61>o de sua fun<75><6E>o <20> chamada duas vezes pela Smarty: uma vez pela tag de abertura,
e outra pela tag de fechamento
(veja <literal>&amp;$repeat</literal> abaixo para como mudar isto).
</para>
<para>
Apenas a tag de abertura da fun<75><6E>o de bloco pode ter atributos.
Todos os atributos passados para as fun<75><6E>es de
template est<73>o contidos em <parameter>$params</parameter> como um array associativo. Voc<6F> pode ou acessar
esses valores diretamente, i.e. <varname>$params['start']</varname>
ou usar <varname>extract($params)</varname>
para import<72>-los para dentro da tabela s<>mbolo. Os atributos da tag de
abertura s<>o tamb<6D>m acess<73>veis a sua fun<75><6E>o
quando processando a tag de fechamento.
</para>
<para>
O valor da vari<72>vel <parameter>$content</parameter>
depende de que se sua fun<75><6E>o <20> chamada pela tag de
fechamento ou de abertura. Caso seja a de abertura, ele ser<65>
<literal>null</literal>, se for a de fechamento
o valor ser<65> do conte<74>do do bloco de template.
Note que o bloco de template j<> ter<65> sido processado pela
Smarty, ent<6E>o tudo que voc<6F> receber<65> <20> sa<73>da do template, n<>o o template original.
</para>
<para>
O par<61>metro <parameter>&amp;$repeat</parameter> <20> passado por
refer<65>ncia para a fun<75><6E>o de implementa<74><61>o
e fornece uma possibilidade para ele controlar quantas
vezes o bloco <20> mostrado. Por defini<6E><69>o
<parameter>$repeat</parameter> <20> <literal>true</literal> na primeira chamada da block-function
(a tag de abertura do bloco) e <literal>false</literal>
em todas as chamadas subsequentes <20> fun<75><6E>o de bloco
(a tag de fechamento do bloco). Cada vez que a
implementa<74><61>o da fun<75><6E>o retorna com o <parameter>&amp;$repeat</parameter>
sendo true, o conte<74>do entre {func} .. {/func} <20> avaliado
e a implementa<74><61>o da fun<75><6E>o <20> chamada novamente com
o novo conte<74>do do bloco no par<61>metro <parameter>$content</parameter>.
</para>
<para>
Se voc<6F> tem fun<75><6E>es de bloco aninhadas, <20> poss<73>vel
descobrir qual <20> a fun<75><6E>o de bloco pai acessando
a vari<72>vel <varname>$smarty->_tag_stack</varname>. Apenas fa<66>a um var_dump()
nela e a estrutura estaria vis<69>vel.
</para>
<para>
See also:
<link linkend="api.register.block">register_block()</link>,
<link linkend="api.unregister.block">unregister_block()</link>.
</para>
<example>
<title>fun<75><6E>o de bloco</title>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: block.translate.php
* Type: block
* Name: translate
* Purpose: translate a block of text
* -------------------------------------------------------------
*/
function smarty_block_translate($params, $content, &amp;$smarty)
{
if (isset($content)) {
$lang = $params['lang'];
// do some intelligent translation thing here with $content
return $translation;
}
}</programlisting>
</example>
</sect1>
<sect1 id="plugins.compiler.functions"><title>Fun<75><6E>es Compiladoras</title>
<para>
Fun<75><6E>es compiladoras s<> s<>o chamadas durante a compila<6C><61>o do template.
Elas s<>o <20>teis para inje<6A><65>o de c<>digo PHP ou conte<74>do est<73>tico time-sensitive
dentro do template. Se h<> ambos, uma fun<75><6E>o
compiladora e uma fun<75><6E>o customiz<69>vel
registrada sob o mesmo nome, a fun<75><6E>o compiladora tem preced<65>ncia.
</para>
<funcsynopsis>
<funcprototype>
<funcdef>mixed <function>smarty_compiler_<replaceable>name</replaceable></function></funcdef>
<paramdef>string <parameter>$tag_arg</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
<20> fun<75><6E>o compiladora s<>o passados dois par<61>metros:
a tag string de argumento da tag - basicamente, tudo a partir
do nome da fun<75><6E>o at<61> o delimitador de fechamento, e o objeto da Smarty. <20> suposto que retorna o c<>digo PHP
para ser injetado dentro do template compilado.
</para>
<para>
See also
<link linkend="api.register.compiler.function">register_compiler_function()</link>,
<link linkend="api.unregister.compiler.function">unregister_compiler_function()</link>.
</para>
<example>
<title>fun<75><6E>o compiladora simples</title>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: compiler.tplheader.php
* Type: compiler
* Name: tplheader
* Purpose: Output header containing the source file name and
* the time it was compiled.
* -------------------------------------------------------------
*/
function smarty_compiler_tplheader($tag_arg, &amp;$smarty)
{
return "\necho '" . $smarty-&gt;_current_file . " compiled at " . date('Y-m-d H:M'). "';";
}
?&gt;</programlisting>
<para>
Esta fun<75><6E>o pode ser chamada em um template da seguinte forma:
</para>
<programlisting>
{* esta fun<75><6E>o <20> executada somente no tempo de compila<6C><61>o *}
{tplheader}</programlisting>
<para>
O c<>digo PHP resultante no template compilado seria algo assim:
</para>
<programlisting>
&lt;php
echo 'index.tpl compiled at 2002-02-20 20:02';
?&gt;</programlisting>
</example>
</sect1>
<sect1 id="plugins.prefilters.postfilters">
<title>Prefiltros/Posfiltros</title>
<para>
Plugins Prefilter e postfilter s<>o muito similares
em conceito; onde eles diferem <20> na execu<63><75>o -- mais
precisamente no tempo de suas execu<63><75>es.
</para>
<funcsynopsis>
<funcprototype>
<funcdef>string <function>smarty_prefilter_<replaceable>name</replaceable></function></funcdef>
<paramdef>string <parameter>$source</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Prefilters s<>o usados para processar o fonte do template
imediatamente antes da compila<6C><61>o. O primeiro par<61>metro da
fun<75><6E>o de prefilter <20> o fonte do template, possivelmente modificado por alguns outros prefilters. O Plugin
<20> suposto retornar o fonte modificado. Note que este fonte n<>o <20> salvo em lugar nenhum, ele s<> <20> usado para
a compila<6C><61>o.
</para>
<funcsynopsis>
<funcprototype>
<funcdef>string <function>smarty_postfilter_<replaceable>name</replaceable></function></funcdef>
<paramdef>string <parameter>$compiled</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
Postfilters s<>o usados para processar a sa<73>da compilada do template (o c<>digo PHP) imediatamente ap<61>s
a compila<6C><61>o ser feita e antes do template compilado ser
salvo no sistema de arquivo. O primeiro par<61>metro
para a fun<75><6E>o postfilter <20> o c<>digo do template compilado,
possivelmente modificado por outros postfilters.
O plugin <20> suposto retornar a vers<72>o modificada deste c<>digo.
</para>
<example>
<title>Plugin prefilter</title>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: prefilter.pre01.php
* Type: prefilter
* Name: pre01
* Purpose: Convert html tags to be lowercase.
* -------------------------------------------------------------
*/
function smarty_prefilter_pre01($source, &amp;$smarty)
{
return preg_replace('!&lt;(\w+)[^&gt;]+&gt;!e', 'strtolower("$1")', $source);
}
?&gt;</programlisting>
</example>
<para></para>
<example>
<title>Plugin postfilter</title>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: postfilter.post01.php
* Type: postfilter
* Name: post01
* Purpose: Output code that lists all current template vars.
* -------------------------------------------------------------
*/
function smarty_postfilter_post01($compiled, &amp;$smarty)
{
$compiled = "&lt;pre&gt;\n&lt;?php print_r(\$this-&gt;get_template_vars()); ?&gt;\n&lt;/pre&gt;" . $compiled;
return $compiled;
}
?&gt;</programlisting>
</example>
</sect1>
<sect1 id="plugins.outputfilters"><title>Filtros de sa<73>da</title>
<para>
Filtros de sa<73>da operam na sa<73>da do template, depois que o template <20> lido e executado, mas
antes a sa<73>da <20> mostrada.
</para>
<funcsynopsis>
<funcprototype>
<funcdef>string <function>smarty_outputfilter_<replaceable>name</replaceable></function></funcdef>
<paramdef>string <parameter>$template_output</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
O primeiro par<61>metro para a fun<75><6E>o do filtro de sa<73>da <20> a sa<73>da do template que precisa ser processada, e
o segundo par<61>metro <20> a inst<73>ncia da Smarty invocando o plugin.
O plugin deve fazer o precessamento e
retornar os resultados.
</para>
<example>
<title>output filter plugin</title>
<programlisting>
/*
* Smarty plugin
* -------------------------------------------------------------
* File: outputfilter.protect_email.php
* Type: outputfilter
* Name: protect_email
* Purpose: Converts @ sign in email addresses to %40 as
* a simple protection against spambots
* -------------------------------------------------------------
*/
function smarty_outputfilter_protect_email($output, &amp;$smarty)
{
return preg_replace('!(\S+)@([a-zA-Z0-9\.\-]+\.([a-zA-Z]{2,3}|[0-9]{1,3}))!',
'$1%40$2', $output);
}
</programlisting>
</example>
</sect1>
<sect1 id="plugins.resources"><title>Recursos (Resources)</title>
<para>
Os plugins de Recursos s<>o como uma forma gen<65>rica de fornecer c<>digos fontes de template
ou componentes de script PHP para a Smarty. Alguns exemplos de recursos:
banco de dados, LDAP, mem<65>ria compartilhada, sockets, e assim por diante.
</para>
<para>
H<> um total de 4 fun<75><6E>es que precisam estar registradas
para cada tipo de recurso. Cada fun<75><6E>o receber<65>
o recurso requisitado como o primeiro par<61>metro e o objeto da Smarty como o <20>ltimo par<61>metro. O resto
dos par<61>metros dependem da fun<75><6E>o.
</para>
<funcsynopsis>
<funcprototype>
<funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_source</function></funcdef>
<paramdef>string <parameter>$rsrc_name</parameter></paramdef>
<paramdef>string <parameter>&amp;$source</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
<funcprototype>
<funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_timestamp</function></funcdef>
<paramdef>string <parameter>$rsrc_name</parameter></paramdef>
<paramdef>int <parameter>&amp;$timestamp</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
<funcprototype>
<funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_secure</function></funcdef>
<paramdef>string <parameter>$rsrc_name</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
<funcprototype>
<funcdef>bool <function>smarty_resource_<replaceable>name</replaceable>_trusted</function></funcdef>
<paramdef>string <parameter>$rsrc_name</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
A primeira fun<75><6E>o deve devolver o recurso. Seu segundo par<61>metro <20> uma vari<72>vel passada por
refer<65>ncia onde o resultado seria armazenado.
A fun<75><6E>o deve retornar <literal>true</literal> se
ela est<73> apta a devolver com sucesso o recurso e
caso contr<74>rio retorna <literal>false</literal>.
</para>
<para>
A segunda fun<75><6E>o deve devolver a <20>ltima modifica<63><61>o do
recurso requisitado (como um timestamp Unix).
O segundo par<61>metro <20> uma vari<72>vel passada por refer<65>ncia onde o timestamp seria armazenado.
A fun<75><6E>o deve retornar <literal>true</literal>
se o timestamp poderia ser determinado com sucesso,
e caso contr<74>rio retornaria <literal>false</literal>.
</para>
<para>
A terceira fun<75><6E>o deve retornar <literal>true</literal> ou
<literal>false</literal>, dependendo do recurso requisitado
est<73> seguro ou n<>o. Esta fun<75><6E>o <20> usada
apenas para recursos de template mas ainda assim seria definida.
</para>
<para>
A quarta fun<75><6E>o deve retornar <literal>true</literal>
ou <literal>false</literal>, dependendo
do recurso requisitado ser confi<66>vel ou n<>o.
Esta fun<75><6E>o <20> usada apenas para componentes de
script PHP requisitados pelas tags <command>include_php</command> ou
<command>insert</command> com o atributo <structfield>src</structfield>.
Entretanto, ela ainda assim mesmo seria definida para os recursos de template.
</para>
<para>
Veja tamb<6D>m:
<link linkend="api.register.resource">register_resource()</link>,
<link linkend="api.unregister.resource">unregister_resource()</link>.
</para>
<example>
<title>Plugin resource (recurso)</title>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: resource.db.php
* Type: resource
* Name: db
* Purpose: Fetches templates from a database
* -------------------------------------------------------------
*/
function smarty_resource_db_source($tpl_name, &amp;$tpl_source, &amp;$smarty)
{
// do database call here to fetch your template,
// populating $tpl_source
$sql = new SQL;
$sql->query("select tpl_source
from my_table
where tpl_name='$tpl_name'");
if ($sql->num_rows) {
$tpl_source = $sql->record['tpl_source'];
return true;
} else {
return false;
}
}
function smarty_resource_db_timestamp($tpl_name, &amp;$tpl_timestamp, &amp;$smarty)
{
// faz o banco de dados chamar aqui para preencher $tpl_timestamp.
$sql = new SQL;
$sql->query("select tpl_timestamp
from my_table
where tpl_name='$tpl_name'");
if ($sql->num_rows) {
$tpl_timestamp = $sql->record['tpl_timestamp'];
return true;
} else {
return false;
}
}
function smarty_resource_db_secure($tpl_name, &amp;$smarty)
{
// assume que todos os templates s<>o seguros
return true;
}
function smarty_resource_db_trusted($tpl_name, &amp;$smarty)
{
// n<>o usado para templates
}
?&gt;</programlisting>
</example>
</sect1>
<sect1 id="plugins.inserts"><title>Inserts</title>
<para>
Plugins Insert s<>o usados para implementar fun<75><6E>es que s<>o invocadas por tags
<link linkend="language.function.insert"><command>insert</command></link>
no template.
</para>
<funcsynopsis>
<funcprototype>
<funcdef>string <function>smarty_insert_<replaceable>name</replaceable></function></funcdef>
<paramdef>array <parameter>$params</parameter></paramdef>
<paramdef>object <parameter>&amp;$smarty</parameter></paramdef>
</funcprototype>
</funcsynopsis>
<para>
O primeiro par<61>metro para a fun<75><6E>o <20> um array
associativo de atributos passados para o
insert. Ou acessa esses valores diretamente,
i.e. <varname>$params['start']</varname> ou usa
<varname>extract($params)</varname> para import<72>-los para dentro da tabela s<>mbolo.
</para>
<para>
A fun<75><6E>o insert deve retornar o
resultado que ser<65> substitu<74>do no lugar da tag
<command>insert</command> no template.
</para>
<example>
<title>Plugin insert</title>
<programlisting>
&lt;?php
/*
* Smarty plugin
* -------------------------------------------------------------
* File: insert.time.php
* Type: time
* Name: time
* Purpose: Inserts current date/time according to format
* -------------------------------------------------------------
*/
function smarty_insert_time($params, &amp;$smarty)
{
if (empty($params['format'])) {
$smarty->trigger_error("insert time: missing 'format' parameter");
return;
}
$datetime = strftime($params['format']);
return $datetime;
}
?&gt;</programlisting>
</example>
</sect1>
</chapter>
</part>
Reference in New Issue Copy Permalink