Portrait ou Paysage ?

Ce qui vient à l’esprit

On sait que dans une boucle document, on peut accéder aux balises #HAUTEUR et #LARGEUR. Cela signifie que l’on peut aussi mettre un critère limitant la hauteur ou la largeur des DOCUMENTS sélectionnés :

<BOUCLE_doc(DOCUMENTS) {id_article} {largeur < 800}>
#LOGO_DOCUMENT
</BOUCLE_doc>

On pourrait donc être tenté de comparer la largeur et la hauteur de la même façon :

<BOUCLE_doc(DOCUMENTS) {id_article} {largeur < hauteur}>
#LOGO_DOCUMENT
</BOUCLE_doc>

SPIP autorise la première boucle. En effet, on peut comparer n’importe quelle colonne de la base de donnée avec une valeur constante. Cependant dans la 2^e boucle proposée, la valeur à droite n’est pas une constante, mais un nom de colonne. Ce critère va donc échouer.

La solution intuitive n’était pas la bonne.

Une solution limitée : imbriquer les boucles

Quand on dit que la valeur à droite doit être une constante, cela veut dire qu’elle peut être :

• une constante numérique (un id, une taille, etc...),
• une chaîne de caractères (un titre d’article, de rubrique, etc...)
• une expression régulière
• la valeur d’une balise d’une boucle englobante.

Effectivement, quand on est dans une itération spécifique d’une boucle, les valeurs de ses balises sont constantes quand elles sont observées par les boucles imbriquées.

On va donc pouvoir utiliser une boucle englobante pour passer la taille du document à droite de l’opérateur :

<BOUCLE_doc(DOCUMENTS) {id_article}>
<BOUCLE_portrait(DOCUMENTS) {id_document} {hauteur >= #LARGEUR}>
#LOGO_DOCUMENT
</BOUCLE_portrait>
</BOUCLE_doc>

On boucle donc avec _doc pour trouver tous les documents d’un article (mais on pourrait utiliser d’autres critères). Ensuite, la boucle _portrait grâce au critère id_document ne sélectionne qu’un document (celui choisi par la boucle _doc).

Elle vérifie aussi que la hauteur de ce document soit plus grande ou égale à la largeur du document sélectionné par la boucle englobante (donc exactement le même).

Voici donc une première solution fonctionnelle pour sélectionner des documents en fonction de leur orientation.

Malheureusement, un critère souvent utilisé ne marchera pas correctement avec cette boucle : {a,b}. En effet, la limitation du nombre de résultats doit être appliquée à la première boucle. Mais celle ci sélectionne tous les documents et donc le compte de documents sera faussé.

Une solution plus souple : utiliser les doublons

Une solutions pour pouvoir utiliser le critère {a,b} est d’utiliser les doublons :

<BOUCLE_doc(DOCUMENTS) {id_article}>
<BOUCLE_paysage(DOCUMENTS) {id_document} {largeur >= #HAUTEUR} {doublons}>
</BOUCLE_paysage>
</BOUCLE_doc>

<BOUCLE_portrait(DOCUMENTS) {id_aticle} {doublons} {0,5}>
#LOGO_DOCUMENT
</BOUCLE_portrait>

Une première boucle parcours les documents que l’on ne veut pas et n’affiche rien, mais remplie la pile de doublons.
La deuxième boucle parcoure tous les documents sauf ceux qui sont dans doublons, c’est à dire ceux qui n’ont pas été éliminés par la boucle précédente.

Une solution intégrée : fournir de nouveaux critères

Bon, tout cela devient compliqué mais reste du code SPIP pur. Malheureusement, même la deuxième solution — dans des cas spéciaux — a certaines limitations.

Voici une solution utilisant l’extensibilité de la version 1.8 de SPIP, pour ajouter trois nouveaux critères de boucle. C’est du code php mais vous n’êtes pas obligé de le comprendre pour l’utiliser. Les critères {portrait} et {paysage} seront alors disponibles. Par exemple :

<BOUCLE_portrait(DOCUMENTS) {id_article} {portrait} {0,5}>
#LOGO_DOCUMENT
</BOUCLE_portrait>

Il faut placer ce code dans mes_fonctions.php3, ou dans un fichier qu’on incluera depuis mes_fonctions.php3.

Attention, les deux critères utilisent des inégalités strictes pour sélectionner les images. Ainsi, les images carrées : Hauteur = Largeur ne seront pas sélectionnées par ces deux critères. C’est pourquoi on ajoute aussi le critère {carre} qui retourne les images carrées.

<?php

function critere_portrait($idb, &$boucles, $param, $not) {
  $boucle = &$boucles[$idb];
  $table = $boucle->id_table;

  if ($not) 
	$boucle->where[] = $table.".hauteur <= ".$table.".largeur";
  else
	$boucle->where[] = $table.".hauteur > ".$table.".largeur";
}


function critere_paysage($idb, &$boucles, $param, $not) {
  $boucle = &$boucles[$idb];
  $table = $boucle->id_table;

  if ($not) 
	$boucle->where[] = $table.".largeur <= ".$table.".hauteur";
  else 
	$boucle->where[] = $table.".largeur > ".$table.".hauteur";
}

function critere_carre($idb, &$boucles, $param, $not) {
  $boucle = &$boucles[$idb];
  $table = $boucle->id_table;

  if ($not) 
	$boucle->where[] = $table.".largeur != ".$table.".hauteur";
  else
	$boucle->where[] = $table.".largeur = ".$table.".hauteur";
}
?>

Voici quelques explications pour ceux qui s’intéressent au code. Les trois fonctions font essentiellement la même chose :

1. Les deux premières lignes récupèrent la boucle dans laquelle on se trouve et le nom de la table de la base concernée.
2. On vérifie ensuite que le critère n’est pas inversé (par le signe « ! ») ; si c’est le cas, on utilise le critère de comparaison inverse.
3. On ajoute enfin une nouvelle contrainte à la requête qui sera faite à la base. Cette contrainte compare les colonnes hauteur et largeur de la table concernée.