En drupal existe un módulo para implementar un Shoutbox en un sitio web. Es realmente útil y personalizable, sin embargo nosotros hicimos ligeros ajustes al módulo a fin de arreglar dos inconvenientes.

1. El campo de ingreso para el mensaje es de una sola línea, para el usuario es deseable enviar mensajes más largos. Para ello viene bien valerse del artículo publicado dentro de la pagina de parches pendientes del proyecto. Se pueden hacer los siguientes cambios y reemplazar el campo de texto por un área de texto.

//En la línea 525 Cambiar
$form['message'] = array(
    '#type' => 'textfield',
    '#default_value' => $default_msg,
    '#size' => 15,
  );
//Por:
 $form['message'] = array(
    '#type' => 'textarea',   
    '#default_value' => $default_msg,
    '#cols' => 15,
    '#rows' => 4,
  );

2. Para evitar que los usuarios puedan enviar mensajes con cualquier nombre de usuario, deshabilitamos la edición del campo nick, empleando la propiedad enunciada en el API #disabled.

//En la línea 517, agregamos al arreglo ('#disabled' => TRUE,) quedaría de esta forma:
    $form['nick'] = array(
      '#type' => 'textfield',
      '#disabled' => TRUE,
      '#default_value' => ($last_nick) ? $last_nick : $default_nick,
      '#size' => 15,
      '#maxlength' => 30,
    );

Por supuesto siempre se podrán aplicar otro tipo de soluciones, como por ejemplo evitar que el campo de Nick sea renderizado empleando la propiedad #access. El módulo es altamente personalizable, recomendado como buena alternativa para un minichat.

XML Sitemaps: Este módulo, se encarga de la generación automática de mapas de sitio XML para motores de búsqueda. No solo genera el mapa XML, como añadido, los envía cada vez que el contenido cambia o se ejecuta Cron.

NodeWords: Su principal funcionalidad es ayudar con el metaetiquetado del sitio. Este módulo permite la creación de description y keywords que pueden ser declaradas de manera global, por término o por nodo.

LinksChecker: Interesante módulo que chequea el sitio a fin de saber si hay enlaces rotos en algún lugar. Útil para evitar la perdida de usuarios y de pagerank.

PathRedirect: Útil para migraciones de contenido o cambios en la URL. Este módulo se encarga de lo necesario para que las rutas y url queden correctamente redireccionadas.

Es solo un corto resumen seguro que hay más. ¿ Conoces algún otro ?

1 <!— Form for code –>

2 <form action=”<?php echo $_SERVER['PHP_SELF']; ?>” method=”post” style=”margin-bottom: 40px;”><div id=”formulario”>

3 <textarea rows=”20″ cols=”80″ name=”codigo”></textarea><br />

4 <input type=”submit” name=”enviar” value=”Formatear” /></div>

5 </form>

6 <?php

7 if( !empty( $_POST['codigo'] ) ) {

8 $codigo = $_POST['codigo'];

9 $codigo = str_replace( “\t”, ” “, $codigo );

10 $codigo = highlight_string( stripslashes( $codigo ), true );

11

12 $line = 1;

13 $buffer = array();

14 $cod = explode( “<br />”, $codigo );

15 foreach( $cod as $codLine ) {

16 $buffer[] = “<b>$line</b>&nbsp;&nbsp;” . $codLine;

17 $line++;

18 }

19

20 $codigo = implode( “<br />”, $buffer );

21 // HACK:

22 $codigo = str_replace( “<b>1</b>&nbsp;&nbsp;<code>”, “<code><b>1</b>&nbsp;&nbsp;”, $codigo );

23 echo ‘<div id=”formated” style=”border: double #dfdfdf;”><h3> Este es tu código formateado </h3>’;

24 echo ‘<p>’.$codigo.‘</p><hr />’;

25 //Gets the source from a file previously created and modified

26 $abrir=fopen(“tmp.txt”, “w”); //open file

27 fwrite($abrir, $codigo); //save code obtained previously

28 fclose($abrir); //close file

29 $url = ‘http://formatealo.terysoftware.com/tmp.txt’;

30 $lineas = file($url);

31 for ($i = 0; $i <count($lineas); $i++) {

32 $resultado = $resultado.htmlentities($lineas[$i]).“<br />”;

33 }

34

35 echo ‘<h3>Inserta este código en tu sitio </h3>’.$resultado.‘</div>’;

36 }

37 ?>

38

39 </div>

Para solucionar dicho inconveniente pueden agregarse las siguientes lineas al archivo template.php ya sea del engine o del theme.

/**
* Arregla la duplicación de id's "edit-sumit".
*/
function phptemplate_submit($element) {
  static $dupe_ids = array();
  if (isset($dupe_ids[$element['#id']])) {
    $dupe_ids[$element['#id']]++;
    $element['#id'] = $element['#id'] .'-'. $dupe_ids[$element['#id']];
  }
  else {
    $dupe_ids[$element['#id']] = 0;
  }
  return theme('button', $element);
}

<?php
function ObtenerNavegador($user_agent) {
     $navegadores = array(
          'Opera' => 'Opera',
          'Mozilla Firefox'=> '(Firebird)|(Firefox)',
          'Galeon' => 'Galeon',
          'Mozilla'=>'Gecko',
          'MyIE'=>'MyIE',
          'Lynx' => 'Lynx',
          'Netscape' => '(Mozilla/4\.75)|(Netscape6)|(Mozilla/4\.08)|(Mozilla/4\.5)|(Mozilla/4\.6)|(Mozilla/4\.79)',
          'Konqueror'=>'Konqueror',
          'IE7' => '(MSIE 7\.[0-9]+)',
          'IE6' => '(MSIE 6\.[0-9]+)',
          'IE5' => '(MSIE 5\.[0-9]+)',
          'IE4' => '(MSIE 4\.[0-9]+)',
);
foreach($navegadores as $navegador=>$pattern){
       if (eregi($pattern, $user_agent))
       return $navegador;
    }
return 'Desconocido';
}
?>

Luego se puede agregar un condicional que realice una acción según cada resultado. Basado en: http://www.webintenta.com/detectar-el-navegador-con-php.html

1. Generalmente los packs que se encuentran para esta versión son demasiado viejos, y aquellos con gráficos más estilizados se encuentran para la versión 6.x.
2. El módulo se hace bastante inconsistente al trabajar con J-Query Update ya que no permite insertar Emoticons directamente desde el fieldset.
3. Los smileys al ser insertados lo hacen sin una clase lo que hace bastante complicado su manejo en las hojas de estilo.

Cómo crear un pack personalizado para Smileys en Drupal 5

Como lo mencionamos, los packs que vienen para esta versión son bastante anticuados. Hay packs muy estilizados y modernos pero para la versión 6 que emplea archivos XML. Entonces elegimos descargar un tema para Smileys en Drupal 6 y hacer uso de un script que generara un archivo de pack para Drupal 5 a fin de portarlo.

EL tema que portamos es uno llamado Facies

El script que empleamos para convertir nuestras imágenes en un tema de smileys de Drupal 5, teniendo en cuenta que el nombre del icono queda igual al nombre de archivo es el siguiente:

<?php
//Script que genera un archivo .pak para Smileys Drupal 5 usando PHP.
 
$dh=opendir("/home/yourdir/"); //Directorio con los iconos
while(gettype($file=readdir($dh)) != boolean)
{
if(!is_dir("$file") && strpos($file, ".gif"))
{
$file2 = str_replace(".gif","",$file); //Estensión de archivos.
echo $file. "=+:" .$file2. "=+::" .$file2. ":";
echo "<br>";
}
}
closedir($dh);
 
//Modificación del script posteado por yngens en el foro de Drupal.org http://drupal.org/node/169700
?>

El Pack de emoticons que creamos se puede hallar en nuestra web de descargas:
http://www.terysoftware.com/descargas/smileys-facies_theme-d5

Hacer funcionar Smileys en Drupal 5 con J-Query Update

Dado que revisando los Issues no encontramos aparentemente una solución al tropiezo #2, decidimos desviar al usuario y obligarlo a usar la ventana (Pop Up) con los demás smileys que si funciona con J-Query Update. Lamentablemente todos los smileys se muestran en el fieldset por lo que el usuario no se vería tentado a hacer click en el link “Show All” (Que fue previamente habilitado en la página de configuración del módulo). Para tal fín, tuvimos que ingresar al módulo y realizar los siguientes cambios buscando que el fieldset mostrara solo unos pocos emoticons.

En el archivo de configuración del módulo (modules/smileys/smileys.module) hicimos lo siguiente:

En la línea 25 se encuentra una función que ejecuta una consulta de este modo

function _smileys_list($refresh = 0, $whereclause = '') {
 
 if($whereclause != '') {
   $whereclause = ' WHERE ' . $whereclause;
  }
  static $list;
 
  if (!$list || $refresh) {
    $result = db_query('SELECT * FROM {smileys} ' . $whereclause);
    $list = array();
    while ($a = db_fetch_object($result)) {
    $list[] = $a;
    }
  }
  return $list;
}

Lo que hacemos es preparar una nueva lista donde recuperemos no todos los emoticons sino solo algunos de esta manera:

function _smileys_lista($refresh = 0, $whereclause = '') {
 
 if($whereclause != '') {
   $whereclause = ' WHERE ' . $whereclause;
  }
  static $list;
 
  if (!$list || $refresh) {
    //Se limita la consulta a  registros.
    $result = db_query('SELECT * FROM {smileys} ' . $whereclause.'LIMIT 5'); 
    $list = array();
    while ($a = db_fetch_object($result)) {
    $list[] = $a;
    }
  }
  return $list;
}

Estas listas luego son empleadas por otra funciones como los son _smileys_select_table, y smileys_table(). Lo que hacemos es duplicar estas funciones pero en esta ocasión pasamos como parámetro la función que creamos (smileys_lista), en ves de smileys_list a las funciones. De esta manera el fieldset solo mostrará cinco emoticons. Las nuevas funciones las nombramos con un 2 al final y les pasamos como parametro la lista original _smileys_list().

//Funciones primitivas
function _smileys_select_table() {
 
  $content = '';
 
  $list = _smileys_lista();
 //Con la nueva lista
  foreach ($list as $smiley) {
 
    $acronyms = explode(' ', $smiley->acronyms);
    $alt = check_plain(implode('  ', $acronyms));
    $desc = implode('  ', $acronyms);
    $content .= '<span><img src="'. check_url(base_path() . $smiley->image) .'" title="'. check_plain($smiley->description) .'" alt="'. $acronyms[0] .'" class="smiley-class"/></span>';
  }
 
  return $content;
}
 
function smileys_table() {
 
  drupal_add_js(drupal_get_path('module', 'smileys') .'/smileys.js');
  drupal_add_css(drupal_get_path('module', 'smileys') .'/smileys.css');
  $form = array();
  $output = '';
  $header = array(t('Smiley'), t('Acronyms'));
  $rows = array();
  $list = _smileys_lista(1);
 //Con la nueva lista
  foreach ($list as $smiley) {
  $acronyms = explode(' ', $smiley->acronyms);
    $rows[] = array(
      '<img src="'. check_url(base_path() . $smiley->image) .'" alt="'. $acronyms[0] .'" title="'. check_plain($smiley->description) .'" class="smiley-class" />',
      check_plain($smiley->acronyms)
    );
  }
 
  $form['smileys'] = array(
    '#type' => 'fieldset',
    '#title' => t('Smileys'),
    '#collapsible' => TRUE,
  );
 
  $form['smileys']['smileys_box'] = array(
 
    '#type' => 'markup',
    '#value' => theme('table', $header, $rows),
  );
 
  $output .= drupal_render($form);
  return $output;
 
}
 
//Funciones duplicadas
function _smileys_select_table2() {
 
  $content = '';
  $list = _smileys_list();
 //Con la lista primitiva.
  foreach ($list as $smiley) {
    $acronyms = explode(' ', $smiley->acronyms);
    $alt = check_plain(implode('  ', $acronyms));
    $desc = implode('&nbsp; ', $acronyms);
    $content .= '<span><img src="'. check_url(base_path() . $smiley->image) .'" title="'. check_plain($smiley->description) .'" alt="'. $acronyms[0] .'" class="smiley-class"/></span>';
  }
 return $content;
}
 
function smileys_table2() {
 
  drupal_add_js(drupal_get_path('module', 'smileys') .'/smileys.js');
  drupal_add_css(drupal_get_path('module', 'smileys') .'/smileys.css');
  $form = array();
  $output = '';
  $header = array(t('Smiley'), t('Acronyms'));
  $rows = array();
  $list = _smileys_list(1);
 //Con la lista primitiva
  foreach ($list as $smiley) {
  $acronyms = explode(' ', $smiley->acronyms);
    $rows[] = array(
      '<img src="'. check_url(base_path() . $smiley->image) .'" alt="'. $acronyms[0] .'" title="'. check_plain($smiley->description) .'" class="smiley-class" />',
      check_plain($smiley->acronyms)
    );
  }
 
  $form['smileys'] = array(
    '#type' => 'fieldset',
    '#title' => t('Smileys'),
    '#collapsible' => TRUE,
  );
 
  $form['smileys']['smileys_box'] = array(
    '#type' => 'markup',
    '#value' => theme('table', $header, $rows),
  );
 
  $output .= drupal_render($form);
  return $output;
}

Por ultimo, como modificamos las funciones de las tablas, el Pop-Up nos mostraría solo cinco emoticons. Por lo que tenemos que cambiar a fin de que recupere la tabla completa y no la recortada. La función que controla los elementos del Pop-Up es smileys_list(), poor lo que le cambiamos la tabla _smileys_select_table por la nueva es decir la #2.

function smileys_list() {
 
  print '<div class="smileysWindowtext">'. t('Click to insert acronym. [<span class="smiley-class" id="closeSmileys">Close</span>]') .'</div><div class="smileysWindow">'. _smileys_select_table2() .'</div>';
 
}

Con esto obtendremos un fieldset con solo cinco emoticons, y guiaremos al usuario a emplear el enlace para ver los demás.

Añadir una clase de CSS a los smileys en Drupal 5

Para añadir la clase a los emoticons hay que editar una linea en el módulo. (modules/smileys/smileys.module) función smileys_filter_process().

function smileys_filter_process($text) {
 
  $text = ' '. $text .' ';
 
  $list = _smileys_list();
 
  foreach ($list as $smiley) {
 
    $acronyms = explode(" ", $smiley->acronyms);
 
    $alt = str_replace('\\', '\\\\', check_plain($smiley->description));
 
    foreach ($acronyms as $a) {
 
      if ($smiley->standalone)
 
        //Añadimos en la siguiente cadena lo siguiente: class=\"img_smiley\" poniendo back_slash para escapar las comillas.
        $text = eregi_replace("([ ,\.\?!:\(\)\r\n\<\>])". preg_quote($a) ."([ ,\.\?!:\(\)\r\n\<\>])", "\\1<img src=\"". check_url(base_path() . $smiley->image) ."\" class=\"img_smiley\" title=\"". check_plain($alt) ."\" alt=\"". check_plain($alt) ."\" />\\2", $text);
 
      else
 
        $text = eregi_replace(preg_quote($a), '<img src="'. check_url(base_path() . $smiley->image) .'" class="img_smiley" title="'. check_plain($alt) .'" alt="'. check_plain($alt) .'" />', $text);
 
    }
 
  }
 
  $text = substr($text, 1, -1);
 
 
 
  return $text;
 
}

Con esto habremos creado una clase img_smiley para los emoticons que se imprimen en el sitio.

Siguiendo estos procedimientos dimos solución a los tres problemas planteados al inicio del post.

Específicamente el ejemplo #1 se ajustaba a una idea que nos surgió de que los personajes de nuestro logo empujaran los menus. Por ser desarrollado sobre J-Query existía una alta posibilidad de que pudiera integrarse con Drupal y de hecho así lo fué, pero ¿ Como hacer que se integrara completamente con la potente gestión de contenido que ofrece Drupal ?.

Dado que Drupal esta desarrollado sobre PHP y es un CMS bastante personalizable, decidimos crear un pequeño script que embedido en el template generara el algoritmo necesario en HTML y JavaScript para cada menu existente.

La manera como se obtuvieron los menús existentes fue capturando la variable $primary_links que es una arreglo y empleando las variables contenidas en dicho arreglo para cada menú. El array $primary_links consta de los siguientes registros por cada menu:

$primary_links => array(1) {
	["some_menu"]=>  array(3) {
		["attributes"]=>  array(1) {
			["title"]=>  string(33) "Titulo al posar el cursor"
		}
		["href"]=>  string(6) "node/6"
		["title"]=>  string(9) "Principal"
	}
}

El número de elementos que contendrá el array $primary_links depende directamente del número de menús que hallan sido creados. Para que un menú se muestre animado con kwicks debe cada opción estar codificada así:

<ul class="kwicks">
	<li id="kwick1">Menu 1</li>
	<li id="kwick2">Menu 2</li>
</ul>

De modo que lo que hacemos es emplear la sentencia de control foreach para que por cada elemento del arreglo nos genere un menú siguiendo el patrón anterior. Para organizar y estilizar de una mejor manera, decidimos dentro de cada <li> declarar un <h2>(Por ser un subtitulo creemos que es semánticamente correcto) y un <label>. Tambíen cabe mencionar que en el script se emplea una variable de control $n a fin de que los identificadores no se repitan y no incumpla el XHTML. Por último era necesario recuperar el alias de url en ves de la url original, ya que de emplear la original nuestro usuarios estarían siendo dirigidos a páginas del tipo “node/#”. A continuación el pequeño script debidamente comentado. Este script fue insertado en un <div$gt; dentro del template principal (page.tpl.php). ver acerca de PHPTemplate y maqueteado en Drupal.

<div id="kwickmenu">
<ul class="kwicks">
<h2 class="main_links">
					<label>
					<a title="'.$option[" href="../../../../'.$nombre["> '.$option["title"].'
					</a>
					</label></h2>
';}
		/*De lo contrario imprimir sin el alias (path original)*/
		else {
		echo '
	<li id="kwick'.$n.'">
<h2 class="main_links">
					<label>
					<a title="'.$option[" href="../../../../'.$option["> '.$option["title"].'
					</a>
					</label></h2>
</li>
';}
		$n++;		/* Incrementamos el identificador para la siguiente iteración*/
		}
		?&gt;</ul>
</div>

comentado. Este script fue insertado dentro del template principal (page.tpl.php). ver acerca de PHPTemplate y maqueteado en Drupal.

De esta manera se integraron los menús con Drupal. Es importante hacer referencia a las hojas de estilo y scripts que vienen contenido en el paquete de kwicks para que funcione correctamente. El resultado se puede apreciar en nuestra web TerySoftware, un menú animado haciendo uso de un efecto de acordeón.

1. Se descarga y descomprime la versión a la cual se va a a hacer el update.
2. Se copia dentro de la versión los archivos que por configuración del sitio no deben sufrir cambios. (Nosotros realizamos copias de la carpeta sites, y files).
3. Se ingresa al sitio como administrador y se deshabilitan todos aquellos módulos que no vengan incluidos en el core de Drupal.
4. Se sube la actualización al servidor sobreescribiendo aquellos archivos que se encuentren duplicados.
5. Se lleva a cabo la ejecución del script update.php (http://sitio.com/update.php)
6. Una vez terminada la actualización, se habilitan de nuevo los módulos extras.

Siguiendo este proceso se puede evitar de manera sencilla traumatismos en las actualizaciones. Es sumamente importante que los scripts de update e install no estén al acceso del publico. Esto porque un usuario anónimo podría llevar a cabo un downgrade de algún modulo o tratar de instalar de nuevo Drupal. Por esta razón es recomendable retirar estos scripts del raíz.

Cuando se realiza el maqueteado en XHTML  se tiene en cuenta que cada div creado debe tener un identificador. Son precisamente los identificadores, clases y otros atributos similares los que permiten relacionar la estructura con el estilo. Cuando el navegador interpreta el documento, lee en las hojas de estilo las normas declaradas y las aplica a los elementos correspondientes. Para explicar de una manera más clara como se usan las CSS podemos ver un ejemplo.

Si crearamos un div con identificador “nuevodiv”…

<div id="nuevodiv"></div>

Podremos aplicar normas de estilo en las css relacionando el estilo con el identificador que escogimos en el XHTML.

#nuevodiv
{
display: block;
float:     left;
background: #fefefe;
}

El navegador recorrerá el código y al encontrar el identificador en el div,  aplicará el estilo indicado en las CSS.

Para hacer de las hojas de estilo un elemento más modular, las hojas de estilo cuentan con una jerarquía definida que permite aplicar estilos diferentes aún a elementos HTML muy específicos sin acudir siempre a un identificador. Por ejemplo las clases, permiten añadir normas de estilo a etiquetas definidas en el HTML pero que a nivel de la vista adquieren una connotación diferente.

Por ejemplo podríamos  tener dos títulos h2, uno estándar y otro de clase h2rojo que es de color rojo.

<h2>Un título estandar</h2>
<h2 class="h2rojo"> Un título rojo </h2>

En la hoja de estilos declararíamos:

//Las clases se declaran anteponiendo un punto, los identificador con el caracter #
h2 .h2rojo{
color: red;
}

Existen varias aplicaciones que permiten realizar el maqueteado de una manera más rápida y eficiente. Se pueden usar herramientas libres como Quanta (Del entorno KDE) o incluso plugins del navegador como lo es Firebug. Este tipo de aplicaciones permiten una visión del resultado a medida que se va añadiendo estilo a las diferentes secciones del HTML.

Lo que permite ganar habilidad en el uso de CSS y aprovechar al máximo lo que ofrecen, es el conocer muy bien la sintaxis y sus propiedades. Para esto hay hojas que contienen resúmenes cortos que son de gran ayuda cuando se esta haciendo el maqueteado. En nuestra sección de descargas se encuentra una de estas hojas de cheats de CSS. Viene bien tener un sitio donde se pueden encontrar las propiedades mas utilizadas y demostraciones de uso como W3Schools.

Una vez realizados estos pasos, se validan tanto el XHTML como las CSS para corroborar que se ha codificado conforme el estándar.

Validador de XHTML

Validador de CSS

Una vez se tienen los documentos validados, se prosigue con la creación del tema para Drupal.

El mayor énfasis que se hizo en el maqueteado fue en un portal orientado al usuario final, de navegación simple y cómoda, sofisticado, estético, con la información a la mano, cumpliendo los estándares de codificado y garantizando una página atractiva a los motores de búsqueda (Clave en el posicionamiento).

El primer paso es crear la estructura en XHTML, la ídea principal es hacer uso correcto del lenguaje para garantizar una web con buena semántica y sin etiquetas de estilo impropias (Ej: font, center, bgcolor). Lo que garantiza esto, es que la web sea entendida por la mayoría de navegadores, y además tener una web donde la semántica y estructura están claramente separadas del estilo visual.

Drupal es un CMS construido bajo la arquitectura (Modelo - Vista - Controlador) MVC. A grandes rasgos este tipo de arquitectura busca distribuir la aplicación en tres partes diferentes que se comunican entre sí, garantizando aplicaciones de fácil mantenimiento y escalables. La razón por la que se toca el tema es porque Drupal utiliza motores de plantillas para comunicar la lógica y la parte de interfaz de usuario. Básicamente el motor de plantillas permite combinar el XHTML con las variables y resultados provenientes del controlador (Componente Lógico), lo que nos garantiza seguir disfrutando de la potencia de Drupal (Manejo de contenido) aún cuando cambiemos totalmente el HTML.

Algo a tener claro es que Drupal no es una herramienta para hacer sitios estéticos y de elevado concepto gráfico. No hay que perder de vista que lo que el navegador interpreta siempre es HTML , de modo que la potencia de Drupal no radica en el diseño por el contrario, en garantizar una unión excelente entre el HTML (Vista) y una robusta parte lógica de manejo de contenido, usuarios, etc… Por supuesto esto no quiere decir que no existan sitios Drupal de excelente estética, de hecho la mayoría lo son. Esta parte ya depende de un buen diseñador.

Bueno después de la introducción manos a la obra, primero se redacta todo el HTML teniendo en cuenta ciertas prácticas:

1. Crear un documento cuya estructura sean Divs, en lo posible no utilizar tablas “tableless”.

2. A cada Div asignarle un Id único, con el que después nos podamos referir a el en la hoja de estilos.

3. Hacer un uso correcto de la semántica del XHTML, usar etiquetas <h1> cuando sean títulos de primer nivel, <strong> para información importante, etc…

4. Toda etiqueta que se abre debe ser cerrada, de acuerdo al estándar.

Una vez realizada la estructura viene la parte importante, ¿ cómo se combina la vista HTML con la parte lógica de Drupal?

Resumiendo, Drupal almacena los resultados de sus operaciones lógicas en variables predefinidas propias de su entorno. Luego esas variables se asignan al motor de plantillas para emplearlas en la impresión de la vista. El motor que se eligió para el tema grafico de nuestro portal fue PHPTemplate. Este motor permite utilizar directamente código en php dentro del HTML con solo abrir las etiquetas <?php ?>; sin embargo, para que el documento sea interpretado por el motor su extensión debe ser cambiada a tpl.php.

Lo que sigue es hacer uso de la variables proporcionadas por Drupal para imprimir los contenidos, bloques, menús, títulos que Drupal genera en su lógica. En un ejemplo sencillo, si se quiere imprimir el título de la pagina y luego el contenido dentro de un div al que identificamos como contenido tendríamos algo de este estilo:

<html>
<head>
<title><?php print $head_title ?></title>
</head>
<body>
<div id="contenido>
<?php print $contenido ?>
</div>
</body>
</html>

Donde las variables empleadas ($title, $content) son variables que Drupal tiene por defecto en su API y que se imprimen formateadas es decir con HTML incluido (En su mayoría).

Para referencia en la sección de descargas de nuestra web (Tery - Descargas) se encuentra un resumen (En Inglés) de las variables propias que proporciona Drupal para uso con PHPTemplate.