Un tema identifica tutto ciò che consente di visualizzare i contenuti del sito secondo una rappresentazione grafica definita dal tema stesso. I contenuti del sito sono quindi sempre gli stessi ma posizionati e visualizzati in modo diverso in funzione del tema scelto.
In generale un tema è costituito dai seguenti elementi:
Le regioni
Le regioni indicano come i diversi conenuti da visualizzare sulla pagina devono essere posizionati.
In pratica rappresentano lo scheletro della pagina, una serie di buchi da riempire con contenuti.
La struttura maggiormente usata per le regioni è la seguente:
Una intestazione (header), una o due barre laterali a sinistra e a destra (sidebar) per blocchi, menu, pubblicità, una regione centrale (content) contenente il contenuto principale della pagina e una regione a fondo pagina (footer) per informazioni secondarie del sito. Nulla vieta naturalmente di complicare la pagina definendo più regioni.
I fogli di stile CSS
Uno o più file contenenti le definizioni degli stili da applicare ai tag HTML del tema.
Il file principale per definizione è il file style.css
I file template
Sono i file che applicano il codice HTML ai contenuti da visualizzare. Questi file hanno sempre
estensione .tpl.php
I temi di Drupal hanno quattro file template fondamentali che si trovano sempre nella directory del tema.
Il file template.tpl.php
In questo file possono essere implementate funzioni che consentono di eseguire un override delle funzioni di base della tematizzazione.
Ad esempio il codice HTML per i link che compaiono sotto un nodo quando è mostrato in modalità sommario (teaser) come leggi tutto, aggiungi un commento etc, è definito nella funzione di base theme_links(). Volendo visualizzare in modo diverso questi link si potrà definire la funzione miotema_links() nel file template.tpl.php. Drupal trovando questa nuova funzione, la eseguirà al posto della theme_link().
Immagini e icone
Immagini e icone di corredo al tema.
QUESTA SEZIONE E' IN LAVORAZIONE
----------------------------------------------
Quando Drupal deve generare il codice HTML per elementi come nodi, blocchi , menu, breadcrumb, links e altro, cerca, per il tema corrente, le funzioni e file teplate che consentono di codificare gli elementi richiesti.
La ricerca avviene applicando regole sulla priorità di ricerca, sui nomi e sulla posizione delle funzioni e dei file all'interno delle directory e dei moduli che consentono a Drupal di ottenere una elevata personalizzazione del sistema.
Conoscendo e seguendo le regole di ricerca è possibile personalizzare un sito generando nuove funzioni e file template in base alle proprie esigenze.
Nome del tema
Il nome del tema deve essere diverso dal nome di qualsiasi modulo
Directory del tema
Tutti i file appartenenti alla definizione di un tema , devono stare all’interno di una propria subdirectory che prende il nome del tema. La subdirecotory può essere contenuta all'interno di una delle seguente directory:
Il motore di elaborazione del tema controllerà , per il tema selezionato, la presenza di file template con estensione .tpl.php.
Il file screenshot del tema
Il file deve essere in formato .png di dimensioni 150x90.
Se presente viene mostrato nella pagina di amministrazione dei temi.
Il file di stile del tema
Il tema utilizza come dichiaratore di stile il file style.css per default.
Altri file possono essere caricati utilizzando l'istruzione @import dei file css.
Temi multipli con più file di stile
E’ possibile creare temi che differiscono per il solo file di definizione degli stili css:style.css.
Per fare questo bisogna creare nella directory di base del tema, delle subdirectory contenenti i file style.css. Ogni subdirectory costituirà un nuovo tema. Ad Esempio:
miosito/sites/all/themes/miotema_A/ (directory principale del tema)
Il motore riconoscerà tre temi: miotema_A, miotema_B, miotema_C.
Ciascun tema utilizzerà i file di base con estensione .tpl.php, e ciascuno avrà nella propria subdirectory il file di stile style.css.
Gli argomenti trattati fanno riferimento alla versione 5.x di Drupal
Funzioni principali:
phptemplate_regions()
drupal_set_content($region=NULL,$data=NULL)
I temi possono definire ed implementare un numero generico di regioni.
Le regioni sono essenzialmente contenitori di... contenuti.
Le regioni suddividono la pagina del browser in aree che costituiranno i limiti in cui visualizzare i contenuti stessi. Così, generalmente, tutti i temi hanno una regione per:
ed altre regioni che possono complicare notevolmente il layout del sito.
Definizione delle regioni
Le regioni sono definite mediante una funzione php che torna un array associativo contenente la codifica delle regioni e la loro descrizione utilizzata nella pagina di amministrazione dei blocchi.
La funzione è la seguente:
function phptemplate_regions() {
return array(
'left' => t('left sidebar'),
'right' => t('right sidebar'),
'content' => t('content'),
'header' => t('header'),
'footer' => t('footer')
);
}Il primo nome della regione diventa la regione di default per il posizionamento di blocchi nel caso in cui non sia dichiarata espressamente una regione.
Nel caso di PhpTemplate Engine la funzione phptemplate_regions() è contenuta nel file: miosito/themes/engines/phptemplate/phptemplate.engine.
Drupal prima di chiamare questa funzione , verifica se esiste una funzione analoga fornita nei file template del tema corrente e che si chiami miotema_regions().
Per cui, per personalizzare le regioni di un tema, bisogna definire la funzione miotema_regions() nel file template.php nella directory del tema.
function miotema_regions() {
return array(
'regione1' => t('regione1'),
'regione2' => t('regione2'),
'regione3' => t('regione3'),
'header' => t('header'),
'footer' => t('footer')
);Nel caso di .theme Engine la funzione è contenuta nel file del tema miotema.theme
Per riempire una regione è possibile utilizzare la funzione
function drupal_set_content($region = NULL, $data = NULL) {
static $content = array();
if (!is_null($region) && !is_null($data)) {
$content[$region][] = $data;
}
return $content;
}Es.: drupal_set_content('left', 'Hello there.')
Gli argomenti trattati fanno riferimento alla versione 5.x di Drupal
Il motore phptemplate è contenuto nella direcotory themes/engines/phptemplate ed è costituito dai seguenti file:
1) phptemplate.engine contenente le funzioni di default per la gestione di blocchi, box. commenti, nodi
2) default.tpl.php non è ancora chiaro l'uso
3) node.tpl.php per la stampa dell’oggetto nodo
4) block.tpl.php per la stampa dell’oggetto blocco
5) box.tpl.php per la stampa dell’oggetto box
6) comment.tpl.php per la stampa dell’oggetto commento
Questi sono alcuni dei file necessari per la gestione di un tema di default. Ma per la realizzazione del tema sono necessari altri due file,fondamentali, contenuti obbligatoriamente nella subdirectory del tema selezionato:
page.tpl.php è il file principale del tema che definisce il layout del tema.
style.css contiene la definizione degli stili del tema.
Ogni tema può quindi utilizzare, i due file page.tpl.php e style.css pi ù i cinque file di default .tpl.php contenuti in themes/engines/phptemplate oppure una loro implementazione personalizzata. In questo caso i file si dovranno chiamare allo stesso modo , ma dovranno trovarsi nella subdirectory del tema.
Aggiungere un tema
Per aggiungere un nuovo tema, si deve quindi:
creare una nuova directory con il nome del tema in /sites/all/themes/miotema oppure /themes/miotema
La cosa più semplice, comunque, è prendere i file di un tema esistente, magari di quelli di default (bluemarine), copiarli nella nuova directory e cominciare a modificarli secondo le proprie esigenze.
I blocchi sono costituiti da codice HTML , eventualmente costruito dinamicamente da script PHP, posizionato all’interno di una regione del tema corrente. Esempi di un blocco sono i campi utente/password per il login al sistema, il menu di navigazione e in generale i menu utente, il calendario etc.
Un blocco può anche essere costituito da una singola stringa, immagine o altro da posizionare in una determinata regione del tema.
Per definire un blocco si hanno due possibilità:
Aggiunta da interfaccia di un nuovo blocco utente
In questa modalità un utente con permessi di amministrazione dei blocchi, può creare un nuovo blocco. Basta andare nella pagina di amministrazione dei blocchi ed eseguire Aggiungi blocco.
Impostare un titolo e nell’area Corpo del blocco definire il codice HTML o PHP del nuovo blocco.
Esempio.:
<p>questo è un blocco </p> oppure <?php print “questo è un blocco”; ?>
Attenzione, selezionare l’opzione appropriata per il formato di input.
Blocco che contiene un altro blocco
Un blocco può anche contenere, a sua volta, un altro blocco.
Per richiamare un blocco utente scrivere:
<?php
$block = module_invoke('block', 'block', 'view', 1);
print $block['content'];
?>
Dove il valore 1 indica il delta , ma per i blocchi utenti rappresenta il primo blocco creato, 2 il secondo blocco creato etc. etc. Questo valore può essere letto nella tabella blocks di MySQL nel campo delta.
Il codice scritto dall’utente &erave; invece contenuto nella tabella boxes nel campo body mettendo in join i campi boxes.bid = blocks.delta.
Definizione di un modulo
Per definire un blocco all’interno di un modulo Drupal, è necessario implementare la funzione nomemodulo_block() all’interno del modulo. Questo esula dalla presente documentazione e si rimanda l’argomento alla trattazione dei moduli.
Posizionamento di un blocco
Tutti i blocchi definiti sono visibili nella pagina di amministrazione dei blocchi, da cui è possibile indicare in quale regione visualizzare il blocco.
Template del tema corrente per la visualizzazione del contenuto di un nodo.
E' usato nella fase di preparazione del codice HTML per il contenuto della pagina richiesta, preparazione avviata dalla funzione menu_execute_active_handler()
E' sconsigliato inserire direttamente codice HTML in Drupal, sebbene sia permesso dai formati di input (FilteredHTML,FullHTML). Drupal mette a disposizione delle funzioni proprio per produrre codice HTML personalizzabili all'interno di ciascun tema.
Le funzioni che producono codice HTML, devono però poter funzionare per qualunque tema selezionato. Ad esempio volendo stampare una tabella si può usare la funzione theme_table() o volendo stampare un blocco si può usare la funzione theme_block(). Tutte le funzioni tematizzate di sistema si trovano nel file includes/theme.inc. Ma se, ad esempio, un tema deve visualizzare l’oggetto ‘blocco’ in un modo particolare può essere implementata la funzione theme_block(), chiamandola miotema_block(), ed inserendola nel file template.tpl.php.
A questo punto è necessario che Drupal sia in grado di sapere che esiste una funzione personalizzata ed usare quella invece della funzione di default. Prendondo come esempio la funzione theme_table(), Drupal, nel momento in cui deve chiamare la funzione, verifica, con le priorità indicate, se:
Il tema implementa la funzione
Verifica se la funzione theme_table() è implementata nel tema corrente.
La funzione implementata:
Il motore di template implementa la funzione
Se il tema non implementa la funziona, Drupal verifica se la funzione theme_table() è implementata dal motore di template del tema corrente.
La funzione implementata:
Il sistema implementa la funzione
Se il motore non implementa la funziona, Drupal chiama la funzione theme_table() implementata da sistema.
La funzione implementata:
Un help delle funzioni di sistema tematizzate può essere trovato in http://api.drupal.org/api/group/themeable/5?sort=asc&order=Name
La funzione theme()
Quando abbiamo bisogno di chiamare una funzione tematizzata, è bene non chiamare la funzione direttamente, ma lasciare che sia Drupal a fare questo per noi tramite la funzione theme('block',args). Infatti supponiamo di voler visualizzare una tabella all'interno di codice php scritto da noi, la chiamata alla funzione giusta potrebbe essere del tipo:
function miafunzione() {
......
// stampa tabella
if (isset('miotema_table') miotema_table(.....);
elseif (isset('phptemplate_table') phptemplate_table(.....);
else theme_table();
......
}Tutto questo può essere semplificato utilizzando la funzione theme() e delegare a Drupal la scelta della funzione corretta:
function miafunzione() {
......
// stampa tabella
theme('table',$args);
......
} Abbiamo visto come l'applicazione di un tema agli elementi del sito , venga eseguito da Drupal mediante funzioni come theme_breadcrumb($breadcrumb), theme_links($links, $attributes) o mediante file template come page.tpl.php, node.tpl.php, block.tpl.php. Per tenere traccia di queste e delle altre informazioni necessarie per applicare correttamente un tema agli elementi del sito, Drupal genera il cosiddetto theme registry. Fisicamente il tema registry è costituito da un'array associativa , indicata in seguito come $hooks, contenente tutti i nomi dei possibili hooks (breadcrumb,links,block,node,page) e, per ciascuno di essi, le corrette informazioni per gestire quella tipologia di elemento.L'array generato è salvato nel database. L'individuazione della funzione o del file template da utilizzare avviene passando sempre attraverso la funzione che è alla base della tematizzazione di Drupal: theme($hook,$args). Il parametro $hook indica a quale elemento applicare il tema. Ad esempio theme('breadcrumb',$args) per il breadcrumb, theme('links',$args) per i links del nodo, theme('node',$args) per un nodo, theme('page', $args) per la pagina finale.
Il valore $args indica qui semplicemente il passaggio di uno o più argomenti alla funzione theme().
Infatti come si vede dal frammento di codice della funzione theme
<?php
function theme() {
$args = func_get_args();
$hook = array_shift($args);
static
$hooks = NULL;
if (!isset($hooks)) {
init_theme();
$hooks = theme_get_registry();
}
.....
$info = $hooks[$hook];
.....
}
?>i parametri non sono passati esplicitamente , ma sono letti mediante la funzione func_get_args().
In questo modo possono essere passati un numero di argomenti indefinito che la funzione theme() passerà alla funzione o al file template che effettivamente si occuperà di tematizzare l'elemento.
Il primo parametro è sempre il valore hook che viene estratto dall'array $args.
Dopo aver letto gli argomenti e individuato l'hook, Drupal carica l'array $hooks dal database. La lettura dell'array è eseguita la prima volta che viene chiamata la funzione theme() mediante la funzione theme_get_registry(). Successive chiamate di theme() troveranno l'array $hooks carico in quanto definito come variabile 'static'.
Da dove è letto il theme registry?
Il theme registry è generato ogni volta che si entra nella pagina contenente la lista dei moduli. Dopo averlo generato Drupal salva l'array nel database e precisamente nella tabella CACHE.
In questa tabella, ogni tema ha un suo theme registry salvato nel campo DATA , e individuato dal record con il campo CID uguale a "theme_registry:NomeTema", dove NomeTema è ovviamente il nome del tema. Volendo quindi forzare la rigenerazione del theme registry basterà semplicemente cancellare il record associato al tema.
L'array $hooks
L'array $hooks è un array associativo nella forma $hooks['hook'][propietàX] = valore , dove valore può essere anche un array o un oggetto. Poco più avanti nel frammento di codice, Drupal per comodità, carica in $info le sole informazioni relative all'hook corrente:$hooks[$hook].
Come viene costruita l'array $hooks? Da dove Drupal prende le informazioni in essa contenute?
Vediamo in dettaglio la costruzione dell'array, supponendo di voler generare il theme registry per il tema Minnelli derivato dal tema Garland e gestito dal motore phptemplate.
Entrando in theme(), Drupal verifica l'esistenza della variabile statica $hooks e se non ancora impostata,
avvia l'inizializzazione del tema corrente tramite la init_theme().
Il tema corrente è definito o in $user->theme o , se nullo, con il tema di default letto con la funzione variable_get('theme_default', 'garland').
Tra le operazione attivate durante l'inizializzazione del tema, quella che a noi qui interessa è la creazione del theme registry. Per leggere gli hooks, Drupal usa la funzione _theme_load_registry() definita in theme.inc, che verifica l'esistenza del theme registry nella tabella CACHE e in caso affermativo riporta l'array contenuto nel campo DATA, altrimenti avvia la sua costruzione.
Nel secondo caso, Drupal dovrà quindi individuare tutti gli hooks e le loro proprietà definiti all'interno del sistema.
La costruzione del theme registry avviene in due fasi:
a) Individuazione di tutti gli hooks definiti nel sistema;
b) Modifica dei parametri degli hooks letti mediante ricerca di funzioni e/o file template personalizzate.
La funzione che avvia la costruzione del theme registry è la funzione _theme_build_registry($theme, $base_theme, $theme_engine) in cui i parametri indicano il nome del tema, il tema base di riferimento (nullo se il tema è già un tema base) , il nome del motore di gestione del tema, nel nostro caso phptemplate.
Gli hooks appartenenti al theme registry sono definiti all'interno dei moduli.
Ogni modulo che vuole esporre i propri hooks deve implementare la funzione nomemodulo_theme() che deve fornire un'array contenente nomi e proprietà degli hooks da esporre.
Ad esempio il modulo di gestione dei blocchi, implementa la funzione block_theme():
<?php
function block_theme() {
return array(
'block_admin_display_form' => array(
'template' => 'block-admin-display-form',
'file' => 'block.admin.inc',
'arguments' => array('form' => NULL),
),
);
}
?>che espone il solo hook "block_admin_display_form" e indicando che deve essere gestito tramite file template. Dove starà il file template? Se non altrimenti definito Drupal si aspetta di trovarlo nel percorso del modulo. Altri esempi è possibile vederli in node_theme() nel modulo node.module, in comment_theme() nel modulo comment.module etc. Per individuare tutti gli hooks dei moduli Drupal esegue un ciclo su tutti i moduli attivi chiamando per ogni modulo la funzione: _theme_process_registry(&$cache, $name, $type, $theme, $path)
dove:
La funzione _theme_process_registry legge l'array restituito dalla funzione nomemodulo_theme() e aggiunge al theme registry gli hook in essa definiti.
Di seguito indichiamo con $info[] l'array restituito dalla funzione nomemodulo_theme() per un singolo hook.
Per l'esempio precedente si avrebbe:
$info[template]= 'block-admin-display-form'
$info[file]= 'block.admin.inc
$info[arguments]=array('form' => NULL)
e con $hook[] le proprietà generate nel theme registry per l'hook letto, ad esempio per block_admin_display_form .
Ad ogni hooks Drupal assegna le seguenti proprietà:
$hook[type]
Valore sempre presente, definito da codice.
Indica dove l'hook è stato definito. Per i moduli è uguale a 'module'
$hook[theme path]
Indica il percorso del modulo. $hook[theme path]=$path (passato come argomento)
$hook[arguments]
Array.Indica il nome e il valore di default degli argomenti da fornire alla funzione o al file template.
E' il valore $info[arguments]
$hook[function]
Indica il nome della funzione di gestione dell'hook.
Se un modulo non definisce ne la proprietà "template" ne la proprietà "function" Drupal imposta
$hook[function]=theme_hook() come nome della funzione che dovrà gestire l'hook. Naturalmente la funzione theme_hook() deve essere implementata nel modulo.
$hook[file]
Se è impostata la proprietà $info[file] , significa che le funzioni di tematizzazione dell'hook sono definite nel file indicato, ad esempio nomemodulo.inc. La corrispondente proprietà dell'hook sarà:
$hook[file]=$path .'/'. $info['file'] con $path percorso del modulo.
E' possibile mettere le funzioni di gestione anche in file esterni alle directory del modulo , impostando la proprietà $info[path]. In questo caso il valore $hook[file] non viene impostato, ma è caricato immediatamente il file
$info['path'] .'/'. $info['file'] per individuare nelle successive fasi eventuali funzioni di tematizzazione.
$hook[template]
Solo se non definita la proprietà $info[function]
Indica il nome e percorso del file template.
Per default il file template viene definito nel percorso del modulo:
$hook[template] = $path ."\" . $info[template];
$hook[theme paths]
Array.Indica un array di directory in cui cercare eventuali implementazioni per il tema.
Per i moduli è aggiunto o la directory del modulo o la proprietà $info[path] se definita.
$hook[preprocess functions]
Array.Indica un array di funzioni di preprocessing da usare in caso di gestione con file template.
Se è definita l'array $info[preprocess functions] allora sarà $hook[preprocess functions]=$info[preprocess] altrimenti Drupal genera l'array $info[preprocess] avviando la ricerca in tutti i moduli delle seguenti funzioni:
e aggiungendo sempre la funzione template_preprocess definita in theme.inc e, se esistente, la funzione template_preprocess_hook
Al termine della ricerca sarà: $hook[preprocess functions]=$info[preprocess].
Terminato di impostare le proprietà di tutti gli hooks appartenenti al modulo, la funzione _theme_preprocess_registry aggiiungerà gli hooks inidividuati nel modulo corrente all'array generale degli hooks $cache.
Nella fase precedente, Drupal ha individuato tutti gli hook definiti nei moduli tramite le funzioni nomemodulo_theme(). Chi sviluppa un modulo deve fornire anche le funzioni o i file template associati agli hooks esposti in nomemodulo_theme(). Drupal consente però di eseguire un "override" delle funzioni e file template fornite mediante la ricerca di funzioni e template alternativi.
Per ogni hook definito Drupal cerca l'esistenza delle seguenti funzioni in ordine di priorità
- nometema_hook()
- nometemabase_hook()
- engine_hook()
e quindi continuando a suppore minnelli come tema corrente, garland come tema base e phptemplate come motore per i temi , Drupal cercherà le seguenti funzioni:
- minnelli_hook()
- garland_hook()
- phptemplate_hook()
Per i file template chercherà i seguenti file:
- hook.tpl.php nella directory del tema corrente (minnelli)
- hook.tpl.php nella directory del tema base (garland)
Per ogni funzione trovata Drupal imposta:
$hook['function]=<nuovo_nome_funzione>
Per ogni template trovato Drupal imposta:
$hook['template]=<file template>
$hook['path]=<directory del tema>
Infine Drupal modifica anche le seguenti proprietà:
$hook[type]
Il valore è posto uguale a 'base_theme_engine' se la ricerca avviene all'interno della directory
del tema base. E' posto uguale a 'theme_engine' se la ricerca avviene all'interno della directory
del tema corrente.
$hook[theme path]
Indica il percorso del tema.
$hook[theme paths]
Oltre ai paths già individuati, aggiunge il path del tema:
$hook[theme paths][]=$path
$hook[preprocess functions]
Drupal aggiorna la proprietà cercando le seguenti funzioni di preprocessing:
- phptemplate_engine_preprocess
- phptemplate_engine_preprocess_hook
- phptemplate_preprocess
- phptemplate_preprocess_hook
- nometemabase_preprocess
- nometemabase_preprocess_hook
- nometema_preprocess
- nometema_preprocess_hook
L'ultima possibilità di modificare il theme registry è data da Drupal mediante la funzione drupal_alter('theme_registry', $cache).
Questa funzione ricerca e chiama tutte le funzioni nomemodulo_themaregistry_alter($hooks) che possono quindi modificare ulteriormente le informazioni fornite precedentemente. Ad esempio un modulo che implementa funzioni tipo theme_hook() potrebbe utilizzare funzioni differenti in base al contesto in cui si trova.
Riepiloghiamo di seguito le principali funzioni utillizzate per la generazione del theme registry.
_theme_build_registry($theme, $base_theme, $theme_engine)
dove:
$theme è il nome del tema
$base_theme è il tema base di riferimento (nullo se il tema è già un tema base)
$theme_engine è il nome del motore di gestione del tema, nel nostro caso phptemplate.
Contenuta in includes/theme.inc
Questa funzione avvia il processo di costruzione del theme registry.
_theme_process_registry(&$cache, $name, $type, $theme, $path)
dove:
$cache è l'array degli hooks che si sta generando a cui accodare eventuali altri hooks
$name è il nome del modulo o del tema in cui cercare gli hooks
$type = indica il tipo di ricerca che si sta eseguendo. Assume i valori: module, base_theme_engine, base_theme, theme_engine, theme.
$theme nome del modulo o del tema
$path indica la directory del modulo
Definita in includes/theme.inc
E' chiamata cinque volte all'interno della funzione _theme_build_registry(), una per ogni tipologia di ricerca.
1) $type= module
$name e $theme corrispondono al nome del modulo
Ricerca delle definizioni degli hooks nei moduli.
Per eseguire la ricerca chiama le funzioni nomemodulo_theme()
2) $type= base_theme_engine
$name=motore del tema , nel nostro caso: phptemplate
$theme=nome del tema base su cui eseguire la ricerca (garland ad esempio)
$path=percorso del tema
Ricerca le funzioni personalizzate con nome phptemplate_hook() e nometemabase_hook()
Ricerca i template personalizzati nella directory del tema base (garland)
Per eseguire la ricerca chiama la funzione phptemplate_theme() definita in themes/engines/phptemplate
3) $type= base_theme
$name e $theme corrispondono al nome del tema base
$path=percorso del tema base
Per eseguire la ricerca chiama, se esiste, la funzione nometemabase_theme().
Questa funzione non è implementata in Drupal..
4) $type=theme_engine
$name=motore del tema , nel nostro caso: phptemplate
$theme=mode le tema su cui eseguire la ricerca (minnelli ad esempio)
$path=percorso del tema
Ricerca le funzioni personalizzate con nome phptemplate_hook() e nometema_hook()
Ricerca i template personalizzati nella directory del tema (minnelli)
Per eseguire la ricerca chiama la funzione phptemplate_theme() definita in themes/engines/phptemplate
5) $type=theme
$name e $theme corrispondono al nome del tema base
$path=percorso del tema
Per eseguire la ricerca chiama, se esiste, la funzione nometema_theme().
Questa funzione non è implementata in Drupal.
phptemplate_theme($existing, $type, $theme, $path)
dove:
$existing è l'array degli hooks definiti nel sistema
$type uguale a 'base_theme_engine' (ricerca per tema base ) o 'theme_engine' (ricerca per tema derivato)'
$theme è il nome del tema per cui cercare funzioni o template personalizzati
$path è il percorso del tema
Definita in themes/engines/phptemplate/pgptemplate.engine
Praticamente è la funzione che ricerca tutte le funzioni e i file template personalizzati, consentendo allo sviluppatore di eseguire l'override delle funzioni e template di default..