/tags/v4.0/api/fragmenteur/FRAG_Fragmenteur.class.php |
---|
New file |
0,0 → 1,243 |
<?php |
/*vim: set expandtab tabstop=4 shiftwidth=4: */ |
// +------------------------------------------------------------------------------------------------------+ |
// | PHP version 4.1 | |
// +------------------------------------------------------------------------------------------------------+ |
// | Copyright (C) 2004 Tela Botanica (accueil@tela-botanica.org) | |
// +------------------------------------------------------------------------------------------------------+ |
// | This library is free software; you can redistribute it and/or | |
// | modify it under the terms of the GNU Lesser General Public | |
// | License as published by the Free Software Foundation; either | |
// | version 2.1 of the License, or (at your option) any later version. | |
// | | |
// | This library is distributed in the hope that it will be useful, | |
// | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
// | Lesser General Public License for more details. | |
// | | |
// | You should have received a copy of the GNU Lesser General Public | |
// | License along with this library; if not, write to the Free Software | |
// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
// +------------------------------------------------------------------------------------------------------+ |
// CVS : $Id: FRAG_Fragmenteur.class.php,v 1.8 2005/03/08 11:25:48 jpm Exp $ |
/** |
* API : fragmenteur. |
* |
* Cette librairie contient la classe fragmenteur qui permet de créer |
* une série de chiffres pour naviguer de page en page lorsque le |
* résultat d'une recherche est trop long. |
* Une variable globale $TransTab est nécessaire d'où les fonctions : |
* - UnstoreTransTab() |
* - AffTxtNbRes() |
* |
*@package API |
*@subpackage Framenteur |
//Auteur original : |
*@author Jean-Charles GRANGER <tela@vecteur.org> |
//Autres auteurs : |
*@author Alexandre GRANIER <alexandre@tela-botanica.org> |
*@author Jean-Pascal MILCENT <jpm@clapas.org> |
*@copyright Tela-Botanica 2000-2004 |
*@version $Revision: 1.8 $ $Date: 2005/03/08 11:25:48 $ |
// +------------------------------------------------------------------------------------------------------+ |
*/ |
// +------------------------------------------------------------------------------------------------------+ |
// | ENTETE du PROGRAMME | |
// +------------------------------------------------------------------------------------------------------+ |
/*Mettre ici les inclusions de fichiers*/ |
include_once 'FRAG_fragmenteur.fonct.php'; |
// +------------------------------------------------------------------------------------------------------+ |
// | CLASSES | |
// +------------------------------------------------------------------------------------------------------+ |
/*Mettre ici la liste de fonctions.*/ |
/** |
* fragmenteur() - Classe pour séparer un résultat en plusieurs pages. |
* |
* Permet de créer un système de navigation |
* de page de résultat en page de résultat. |
* |
* @author Jean-Charles GRANGER <tela@vecteur.org> |
*/ |
class fragmenteur { |
// Propriétés |
var $separator; |
var $nb_pages; |
var $curr_page; |
var $max_fg_pages; // nombre maximum de numéros de pages qui doivent être affichées |
var $curr_grp; // groupe courrant de nombre de pages |
var $nb_grp; // nbre de groupes total |
var $url; |
// Constructeur |
function fragmenteur($caractere = ' - ', $nombre_p = 10, $url = null) |
{ |
$this->separator = $caractere; |
$this->max_fg_pages = $nombre_p; |
if (is_null($url)) { |
$this->url = $GLOBALS['_GEN_commun']['url']->geturl(); |
} else { |
$this->url = $url; |
} |
} |
/** |
* fragmente() - Méthode qui fragmente des résultats. |
* |
* Permet de fragmenter des résultats. |
* Le tableau des données à passer en paramêtre doit contenir a minima : |
* - $tableau['pstart'] : valeur du début de la page |
* - $tableau['step'] : valeur du pas (nombre d'items par pages) |
* - $tableau['pend'] |
* Pour faire figurer des images sur les liens suivant, précédent, début et fin utiliser |
* des css. |
* |
*@param array tableau qui contient les variables du fragmenteur. |
*@param int le nombre de résultat total. |
*@return string le xhtml permettant de naviguer dans les résultats. |
*/ |
function fragmente($tableau, $nbr_total) |
{ |
$startPrev = $startNext = $tableau['pstart']; |
// Initialisation des variables |
$var_fragmenteur = ''; |
$stockagevar = ''; |
$how_bloc = $tableau['step']; |
$how_pages = ceil($nbr_total / $how_bloc); |
$current_page = ceil(($tableau['pstart'] / $how_bloc)) + 1; |
$this->nb_pages = $how_pages; |
$this->curr_page = $current_page; |
$this->nb_grp = ceil(($this->nb_pages) / ($this->max_fg_pages)); |
$this->curr_grp = floor(($tableau['pstart'] + ($this->max_fg_pages * $tableau['step'])) / ($this->max_fg_pages * $tableau['step'])) - 1; |
// 1- Altération des données de tmpTab pour passer les paramètres de saut de page |
// 1-a- tmpTab de la page précédente |
if ($startPrev > 0) { |
$startPrev = $startPrev - $tableau['step']; |
} |
// 1-b- tmpTab de la page suivante |
$startNext = $startNext + $tableau['step']; |
// Création des variables mises dans le tableau, pour les passer aux pages successives |
if (empty($tableau['args'])) { |
$tableau['args'] = ''; |
} |
foreach($tableau as $tmp_stock => $value) { |
if (($tmp_stock != 'args') && ($tmp_stock != 'pstart')) { |
$stockagevar = $stockagevar.$tmp_stock.','.$value.'!'; |
} |
} |
// Ligne suivante désuette ?? |
$stockagevar = ereg_replace(' ', '{', $stockagevar); |
// Bouton pour groupes de pages précédent |
if ((($this->nb_pages) > ($this->max_fg_pages)) && (($this->curr_page) > ($this->max_fg_pages))) { |
$txt_depart = ( ($this->max_fg_pages) * $tableau['step'] ).' données précédentes'; |
$var_fragmenteur .= '<a class="frag_depart" href="'.$this->url.'&TransTab='.$stockagevar.'pstart,'. |
((($this->curr_grp) - 1) * ($this->max_fg_pages) * $tableau['step']).'!'.$tableau['args'].'" title="'.$txt_depart.'" >'. |
'<span>'.$txt_depart.'</span>'. |
'</a>'."\n"; |
} |
// Bouton pour resultats précédent |
if ($tableau['pstart'] > 0) { |
$txt_precedent = $tableau['step'].' données précédentes'; |
$var_fragmenteur .= '<a class="frag_precedent" href="'.$this->url.'&TransTab='.$stockagevar. |
'pstart,'.$startPrev.'!'.$tableau['args'].'" title="'.$txt_precedent.'">'. |
'<span>'.$txt_precedent.'</span>'. |
'</a>'."\n"; |
} |
// Fragmentation |
$tmp_i = (1 + ( ($this->curr_grp) * ($this->max_fg_pages) )); |
$j = 1; |
while (($tmp_i <= $how_pages) && ($tmp_i <= (($this->max_fg_pages) * (($this->curr_grp) + 1)))) { |
if ($current_page == $tmp_i) { |
$var_fragmenteur .= '<span class="frag_page_courante">'.$tmp_i.'</span>'."\n"; |
} else { |
$stockagevar = ''; |
$tmp_go = ($tmp_i - 1) * $how_bloc; |
foreach($tableau as $tmp_stock_i => $value) { |
if ($tmp_stock_i != 'args') { |
if ($tmp_stock_i == 'pstart') { |
$stockagevar .= 'pstart,'.$tmp_go.'!'; |
} else { |
$stockagevar .= $tmp_stock_i.','.$value.'!'; |
} |
} |
} |
$stockagevar = ereg_replace(' ', '{', $stockagevar); |
$var_fragmenteur .= '<a class="frag_page_autre" href="'.$this->url.'&TransTab='.$stockagevar.$tableau['args'].'">'. |
'<span>'.($tmp_i).'</span>'. |
'</a>'."\n"; |
} |
if (($tmp_i < $how_pages) && ($j < ($this->max_fg_pages))) { |
$var_fragmenteur .= '<span class="frag_separateur">'.$this->separator.'</span>'."\n"; |
} |
$tmp_i++; |
$j++; |
} |
// Bouton pour resultats suivants |
$var_fragmenteur .= ' '; |
if ($tableau['pstart'] + $tableau['step'] < $tableau['pend']) { |
$txt_suivant = $tableau['step'].' données suivantes'; |
$var_fragmenteur .= '<a class="frag_suivant" href="'.$this->url.'&TransTab='.$stockagevar.'pstart,'.$startNext.'!'.$tableau['args'].'" title="'.$txt_suivant.'">'. |
'<span>'.$txt_suivant.'</span>'. |
'</a>'."\n"; |
} |
// Bouton pour groupes de pages suivants |
if ( $this->nb_grp > 1 && ($this->curr_grp < ($this->nb_grp - 1))) { |
$txt_fin = ($this->max_fg_pages * $tableau['step']).' données suivantes'; |
$var_fragmenteur .= ' <a class="frag_fin" href="'.$this->url.'&TransTab='.$stockagevar.'pstart,'. |
((($this->curr_grp) + 1) * ($this->max_fg_pages) * $tableau['step']).'!'.$tableau['args'].'" title="'.$txt_fin.'">'. |
'<span>'.$txt_fin.'</span>'. |
'</a>'."\n"; |
} |
return $var_fragmenteur; |
} |
} |
/* +--Fin du code ---------------------------------------------------------------------------------------+ |
* $Log: FRAG_Fragmenteur.class.php,v $ |
* Revision 1.8 2005/03/08 11:25:48 jpm |
* Remplacement d'id en class car le fragmenteur peut être afficher plusieurs fois dans la même page XHTML. |
* |
* Revision 1.7 2005/03/03 08:40:48 jpm |
* Correction de gestion des guillemets. |
* |
* Revision 1.6 2005/02/24 18:32:08 jpm |
* Correction : changement d'un id en class. |
* |
* Revision 1.5 2005/02/24 17:16:10 jpm |
* Modif des noms des id. |
* |
* Revision 1.4 2005/02/23 17:28:35 jpm |
* Suppression d'image dans le fragmenteur et remplacement par des styles css. |
* Amélioration du code html. |
* |
* Revision 1.3 2004/09/11 19:07:57 jpm |
* Mise en forme. |
* |
* Revision 1.1 2004/09/10 12:44:26 jpm |
* Ajout des classes et fonctions du fragmenteur de page. |
* Leur révision est nécessaire! |
* |
* |
* +--Fin du code ----------------------------------------------------------------------------------------+ |
*/ |
?> |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/tags/v4.0/api/fragmenteur/FRAG_Fragmenteur_Session.class.php |
---|
New file |
0,0 → 1,425 |
<?php |
/*vim: set expandtab tabstop=4 shiftwidth=4: */ |
// +------------------------------------------------------------------------------------------------------+ |
// | PHP version 4.1 | |
// +------------------------------------------------------------------------------------------------------+ |
// | Copyright (C) 2004 Tela Botanica (accueil@tela-botanica.org) | |
// +------------------------------------------------------------------------------------------------------+ |
// | This library is free software; you can redistribute it and/or | |
// | modify it under the terms of the GNU Lesser General Public | |
// | License as published by the Free Software Foundation; either | |
// | version 2.1 of the License, or (at your option) any later version. | |
// | | |
// | This library is distributed in the hope that it will be useful, | |
// | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
// | Lesser General Public License for more details. | |
// | | |
// | You should have received a copy of the GNU Lesser General Public | |
// | License along with this library; if not, write to the Free Software | |
// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
// +------------------------------------------------------------------------------------------------------+ |
// CVS : $Id: FRAG_Fragmenteur_Session.class.php,v 1.10 2005/03/08 11:25:48 jpm Exp $ |
/** |
* API : fragmenteur utilisant les sessions. |
* |
* Cette librairie contient la classe fragmenteur qui permet de créer |
* une série de chiffres pour naviguer de page en page lorsque le |
* résultat d'une recherche est trop long. |
* Cette extension du fragmenteur utilise les sessions. |
* |
*@package API |
*@subpackage Framenteur |
//Auteur original : |
*@author Alexandre GRANIER <alexandre@tela-botanica.org> |
//Autres auteurs : |
*@author Jean-Pascal MILCENT <jpm@clapas.org> |
*@copyright Tela-Botanica 2000-2004 |
*@version $Revision: 1.10 $ $Date: 2005/03/08 11:25:48 $ |
// +------------------------------------------------------------------------------------------------------+ |
*/ |
// +------------------------------------------------------------------------------------------------------+ |
// | ENTETE du PROGRAMME | |
// +------------------------------------------------------------------------------------------------------+ |
/** Inclusion de la classe Fragmenteur principale. */ |
include_once 'FRAG_Fragmenteur.class.php'; |
// +------------------------------------------------------------------------------------------------------+ |
// | CLASSES | |
// +------------------------------------------------------------------------------------------------------+ |
/** |
* Classe pour séparer un résultat en plusieurs page. |
* |
* Basé sur la classe fragmenteur mais utilise les variables |
* de session. |
* |
* @author Alexandre Granier <alexandre@tela-botanica.org> |
*/ |
class fragmenteur_session |
{ |
/** |
* Contient le séparateur des chiffres |
* |
* @var string |
* @access private |
*/ |
var $separator; |
var $nb_pages; |
var $curr_page; |
/** |
* nombre maximum de numéros de pages qui doivent être affichées |
* |
* @var integer |
* @access private |
*/ |
var $max_fg_pages; |
/** |
* groupe courant de nombre de pages |
* par défaut 10 |
* |
* @var integer |
* @access private |
*/ |
var $curr_grp; |
/** |
* nbre de groupes total |
* |
* @var integer |
* @access private |
*/ |
var $nb_grp; |
/** |
*L'url de départ |
* |
* @var string |
* @access private |
*/ |
var $url ; |
/** |
*Le tableau des variables de l'url et des formulaire |
* |
* @var array |
* @access private |
*/ |
var $_variables ; |
/** |
*Le nombre de résultat par page |
* |
* @var integer |
* @access private |
*/ |
var $_pas ; |
/** |
*Le début de l'ensemble de résultat |
* |
* @var integer |
* @access private |
*/ |
var $_debut ; |
/** |
*Le nombre total de résultat |
* |
* @var integer |
* @access private |
*/ |
var $_nb_total ; |
function fragmenteur_session ($caractere = ' - ', $nombre_p = 10) |
{ |
// On va utiliser toutes les variables de l'url et des formulaires disponibles |
global $HTTP_POST_VARS, $_GET, $HTTP_GET_VARS, $GS_GLOBAL ; |
$this->_variables = array_merge($HTTP_GET_VARS, $HTTP_POST_VARS, $_GET) ; |
// On récupère toutes les variables de sessions |
if (!isset($_SESSION['fragment'])) { |
// Il n'y a pas de variable de session, on en crée une et on y met $this->_variables |
$_SESSION['fragment'] = $this->_variables; |
} else { |
// On récupère la variable et on l'affecte à $this->_variables |
// en laissant cependant les valeurs existant déjà dans $this->_variables |
// mise à jour de la variable de session |
$tableau_temp = $_SESSION['fragment']; |
foreach ($tableau_temp as $key=>$value) { |
if (!isset ($this->_variables[$key]) || ($this->_variables[$key] == '')) { |
if (!isset($HTTP_POST_VARS[$key])) { |
$this->_variables[$key] = $tableau_temp[$key] ; |
} else { |
$this->_variables[$key] = ''; |
} |
} |
} |
$_SESSION['fragment'] = $this->_variables; |
} |
$this->separator = $caractere; |
$this->max_fg_pages = $nombre_p; |
// on initialise $this->_debut avec soit 0, soit la valeur de $this->_variables['debut'] |
if (isset($this->_variables['debut']) && $this->_variables['debut'] != '') { |
$this->_debut = $this->_variables['debut'] ; |
} else { |
$this->_debut = 0; |
} |
// on initialise $this->_pas avec soit 20, soit la valeur de $this->_variables['T_REPONSE'] |
if (isset ($this->_variables['T_REPONSE']) && $this->_variables['T_REPONSE'] != '') { |
$this->_pas = $this->_variables['T_REPONSE']; |
} else { |
$this->_pas = 20; |
} |
} |
/** |
* fragmente() - Méthode qui fragmente des résultats. |
* |
* Permet de fragmenter des résultats. |
* Le tableau des données à passer en paramêtre doit contenir a minima : |
* - $tableau['pstart'] : valeur du début de la page |
* - $tableau['step'] : valeur du pas (nombre d'items par pages) |
* - $tableau['pend'] |
* Pour faire figurer des images sur les liens suivant, précédent, début et fin utiliser |
* des css. |
* |
* @access public |
* @param array Tableau qui contient les variables du fragmenteur. |
* @param int Le nombre de résultat total. |
* @return string Le xhtml permettant de naviguer dans les résultats. |
*/ |
function fragmente($nbr_total) |
{ |
$startPrev = $startNext = $this->_debut; |
// Initialisation des variables |
$var_fragmenteur = ''; |
$this->_nb_total = $nbr_total ; |
$how_bloc = $this->_pas ; |
$how_pages = ceil($nbr_total / $how_bloc); |
$this->curr_page = ceil(($this->_debut / $how_bloc))+1; |
$this->nb_pages = $how_pages; |
$this->nb_grp = ceil(($this->nb_pages)/($this->max_fg_pages)); |
$this->curr_grp = floor(($this->_debut + ($this->max_fg_pages * $this->_pas))/(($this->max_fg_pages)*$this->_pas))-1; |
// 1- Altération des données de tmpTab pour passer les paramètres de saut de page |
// 1-a- tmpTab de la page précédente |
if ($startPrev > 0) $startPrev = $startPrev - $this->_pas ; |
// 1-b- tmpTab de la page suivante |
$startNext = $startNext + $this->_pas; |
// Bouton pour groupes de pages précédent |
if ((($this->nb_pages) > ($this->max_fg_pages))&&(($this->curr_page) > ($this->max_fg_pages))) { |
$pstart = ((($this->curr_grp)-1)*($this->max_fg_pages)*$this->_pas); |
$txt_depart = (($this->max_fg_pages)*$this->_pas).' données précédentes'; |
$var_fragmenteur .= '<a class="frag_depart" href="'.$this->url.'&debut='.$pstart.'" title="'.$txt_depart.'" >'. |
'<span>'.$txt_depart.'</span>'. |
'</a>'."\n"; |
} |
// Bouton pour resultats précédent |
if ($this->_debut > 0) { |
$pstart = $startPrev; |
$txt_precedent = $this->_pas.' données précédentes'; |
$var_fragmenteur .= '<a class="frag_precedent" href="'.$this->url.'&debut='.$pstart.'" title="'.$txt_precedent.'" >'. |
'<span>'.$txt_precedent.'</span>'. |
'</a>'."\n"; |
} |
// Fragmentation en page |
$tmp_i = 1 + $this->curr_grp * $this->max_fg_pages ; |
$j = 1; |
while (($tmp_i <= $how_pages) && ($tmp_i <= (($this->max_fg_pages) * (($this->curr_grp) + 1))) && $how_pages != 1) { |
if ($this->curr_page == $tmp_i) { |
$var_fragmenteur .= '<span class="frag_page_courante">'.$tmp_i.'</span>'."\n"; |
} else { |
$tmp_go = ($tmp_i - 1) * $how_bloc; |
$pstart = $tmp_go ; |
$var_fragmenteur .= '<a class="frag_page_autre" href="'.$this->url.'&debut='.$pstart.'">'. |
'<span>'.$tmp_i.'</span>'. |
'</a>'."\n"; |
} |
if (($tmp_i < $how_pages) && ($j<($this->max_fg_pages))) { |
$var_fragmenteur .= '<span class="frag_separateur">'.$this->separator.'</span>'."\n"; |
} |
$tmp_i++; |
$j++; |
} |
// Bouton pour resultats suivant |
if ($this->_debut + $this->_pas < $nbr_total) { |
$pstart = $startNext ; |
$var_fragmenteur .= ' '; |
$txt_suivant = $this->_pas.' données suivantes'; |
$var_fragmenteur .= '<a class="frag_suivant" href="'.$this->url.'&debut='.$pstart.'" title="'.$txt_suivant.'" >'. |
'<span>'.$txt_suivant.'</span>'. |
'</a>'."\n"; |
} |
// Bouton pour groupes de pages suivants |
if ((($this->nb_grp)>1)&&(($this->curr_grp)<(($this->nb_grp)-1))) { |
$pstart = ((($this->curr_grp)+1)*($this->max_fg_pages)*$this->_pas) ; |
$txt_fin = (($this->max_fg_pages)*$this->_pas).' données suivantes'; |
$var_fragmenteur .= '<a class="frag_fin" href="'.$this->url.'&debut='.$pstart.'" title="'.$txt_fin.'" >'. |
'<span>'.$txt_fin.'</span>'. |
'</a>'."\n"; |
} |
if ($var_fragmenteur == '') { |
$var_fragmenteur = ' '; |
} |
return $var_fragmenteur; |
} |
/** |
* Méthode setURL() - |
* |
* @access public |
* @param url Chaine qui contient l'url de départ |
*/ |
function setURL($url) |
{ |
$this->url = $url; |
} |
/** getVariable() Renvoie la valeur d'une variable de l'url ou d'un formulaire |
* |
* @access public |
* @param string Nom de la variable |
* @return mixed La valeur de la variable ou la chaine vide |
*/ |
function getVariable ($cle) |
{ |
if (isset($this->_variables[$cle])) { |
return $this->_variables[$cle]; |
} else { |
return ''; |
} |
} |
/** setVariable() Affecte une valeur à une variable |
* |
* @param string clé |
* @param string valeur |
* @return void |
*/ |
function setVariable ($cle, $valeur) |
{ |
$tableau = $_SESSION['fragment']; |
$tableau[$cle] = $valeur ; |
$_SESSION['fragment'] = $tableau; |
} |
/** fixerLePas() Permet d'indiquer le nombre de résultat souhaité par page |
* |
* @param int le pas |
* @return void |
*/ |
function fixerLePas ($pas) |
{ |
$this->_pas = $pas; |
} |
/** lireLePas() Permet d'obtenir le nombre de résultat souhaité par page |
* |
* @return integer le pas |
*/ |
function lireLePas () |
{ |
return $this->_pas; |
} |
/** lireLeDebut() Permet d'obtenir le nombre du début du résultat |
* |
* @return integer le début |
*/ |
function lireLeDebut () |
{ |
return $this->_debut; |
} |
/** fixerLeDebut() Permet d'indiquer le nombre du début du résultat |
* |
* @return integer le début |
*/ |
function fixerLeDebut ($debut) |
{ |
$this->_debut = $debut; |
} |
/** affNbRes() Affiche le nombre de résultat |
* |
* Permet de créer un petit texte uniforme du type "il y a x resultats sur y"... |
* Possibilité de paramétrer un "modèle" pour afficher selon différentes mises |
* en forme. |
* |
* @access public |
* @param int nombre d'items trouvés par la requête |
* @return string une phrase en HTML |
*/ |
function affNbRes($nombre_total) |
{ |
$this->_nb_total = $nombre_total ; |
// init de $var_affiche |
$var_affiche = ''; |
if ($this->_nb_total > 1) { |
$pluriel_loc = 's'; |
} else { |
$pluriel_loc = ''; |
} |
if ($this->_nb_total > 1) { |
$pluriel_tot = 's'; |
} else { |
$pluriel_tot = ''; |
} |
if ($this->_nb_total > 0) { |
$add_from = $this->_debut + 1; |
$tmp_num = $this->_debut + $this->_pas ; |
if ($tmp_num < $this->_nb_total) { |
$add_to = "$tmp_num"; |
} else { |
$add_to = $this->_nb_total ; |
} |
} |
$var_affiche .= '<b>'.$this->_nb_total.'</b>'.' résultat'.$pluriel_loc."\n"; |
if ($this->_nb_total > 0) { |
$var_affiche .= ' Affichage des données <b>'.$add_from.'</b> à <b>'.$add_to.'</b>.'."\n"; |
} |
return $var_affiche; |
} |
}//Fin classe. |
/* +--Fin du code ---------------------------------------------------------------------------------------+ |
* |
* $Log: FRAG_Fragmenteur_Session.class.php,v $ |
* Revision 1.10 2005/03/08 11:25:48 jpm |
* Remplacement d'id en class car le fragmenteur peut être afficher plusieurs fois dans la même page XHTML. |
* |
* Revision 1.9 2005/03/03 08:40:48 jpm |
* Correction de gestion des guillemets. |
* |
* Revision 1.8 2005/02/28 15:42:15 jpm |
* Initialisation d'une variable de session. |
* |
* Revision 1.7 2005/02/24 18:32:08 jpm |
* Correction : changement d'un id en class. |
* |
* Revision 1.6 2005/02/24 17:16:10 jpm |
* Modif des noms des id. |
* |
* Revision 1.5 2005/02/23 17:28:35 jpm |
* Suppression d'image dans le fragmenteur et remplacement par des styles css. |
* Amélioration du code html. |
* |
* Revision 1.4 2005/02/22 19:32:45 jpm |
* Initialisation de variables. |
* |
* Revision 1.3 2005/02/22 16:21:28 jpm |
* Mise à jour : utilisation des session, mise en forme et suppression d'appel de fichiers inutiles. |
* |
* Revision 1.2 2004/09/11 19:12:38 jpm |
* Début mise en forme. |
* |
* |
* +--Fin du code ----------------------------------------------------------------------------------------+ |
*/ |
?> |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/tags/v4.0/api/fragmenteur/FRAG_fragmenteur.fonct.php |
---|
New file |
0,0 → 1,443 |
<?php |
/*vim: set expandtab tabstop=4 shiftwidth=4: */ |
// +------------------------------------------------------------------------------------------------------+ |
// | PHP version 4.1 | |
// +------------------------------------------------------------------------------------------------------+ |
// | Copyright (C) 2004 Tela Botanica (accueil@tela-botanica.org) | |
// +------------------------------------------------------------------------------------------------------+ |
// | This library is free software; you can redistribute it and/or | |
// | modify it under the terms of the GNU Lesser General Public | |
// | License as published by the Free Software Foundation; either | |
// | version 2.1 of the License, or (at your option) any later version. | |
// | | |
// | This library is distributed in the hope that it will be useful, | |
// | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
// | Lesser General Public License for more details. | |
// | | |
// | You should have received a copy of the GNU Lesser General Public | |
// | License along with this library; if not, write to the Free Software | |
// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
// +------------------------------------------------------------------------------------------------------+ |
// CVS : $Id: FRAG_fragmenteur.fonct.php,v 1.6 2005/02/23 17:28:35 jpm Exp $ |
/** |
* API : fragmenteur. |
* |
* Cette librairie contient les fonctions : |
* - UnstoreTransTab() |
* - AffTxtNbRes() |
* - rechercheAlphabet() |
* |
*@package API |
*@subpackage Framenteur |
//Auteur original : |
*@author Jean-Charles GRANGER <tela@vecteur.org> |
//Autres auteurs : |
*@author Alexandre GRANIER <alexandre@tela-botanica.org> |
*@author Jean-Pascal MILCENT <jpm@clapas.org> |
*@copyright Tela-Botanica 2000-2004 |
*@version $Revision: 1.6 $ $Date: 2005/02/23 17:28:35 $ |
// +------------------------------------------------------------------------------------------------------+ |
*/ |
// +------------------------------------------------------------------------------------------------------+ |
// | ENTETE du PROGRAMME | |
// +------------------------------------------------------------------------------------------------------+ |
/*Mettre ici les inclusions de fichiers*/ |
include_once 'FRAG_Fragmenteur.class.php'; |
// Compatibilité avec les anciennes versions : |
function UnstoreTransTab($chaine) |
{ |
return FRAG_decoupageChaine($chaine); |
} |
function AffTxtNbRes($modele, $tableau, $nb_query_ltd, $nbre_total) |
{ |
return FRAG_afficherTxtNbreResultat($modele, $tableau, $nb_query_ltd, $nbre_total); |
} |
function rechercheAlphabet( $requete, $baseURL, $paramURL = '', $affichageResultAvt = '', $affichageResultAps = '', |
$tablo_formatLigne = array(), $tablo_formatResultat = array(), $messageErreur = '', $fragmenteur = array()) |
{ |
return FRAG_rechercherAvecAlphabet( $requete, $baseURL, $paramURL, $affichageResultAvt, $affichageResultAps, |
$tablo_formatLigne, $tablo_formatResultat, $messageErreur, $fragmenteur); |
} |
// +------------------------------------------------------------------------------------------------------+ |
// | LISTE des FONCTIONS | |
// +------------------------------------------------------------------------------------------------------+ |
/*Mettre ici la liste de fonctions.*/ |
/**Fonction FRAG_afficherTxtNbreResultat() - Affiche un texte formaté. |
* |
* Permet de créer un petit texte uniforme du type "il y a x resultats sur y"... |
* Possibilité de paramétrer un "modèle" pour afficher selon différentes mises |
* en forme. |
* |
* @param string nom du modèle utilisé (vide = modèle par défaut). |
* @param array tableau de résultats |
* - $tableau['pstart'] : valeur du premier item (ex. : pages de 20 items, la 2è page commence au 21è, $tableau['pstart'] = 20) |
* - $tableau['pend'] : valeur du dernier item (nombre total d'items retournés par la requête, sans clause LIMIT |
* - $tableau['step'] : pas de regroupement (x items par page) |
* @param integer nombre d'items trouvés par la requête, avec clause LIMIT |
* @param integer nombre total d'items dans la Base |
* |
* @return string la chaine formatée. |
*/ |
function FRAG_afficherTxtNbreResultat($modele, $tableau, $nb_query_ltd, $nb_total) |
{ |
// Initialisation de $var_affiche |
$var_affiche = ''; |
if ($nb_query_ltd > 1) { |
$pluriel_loc = 's'; |
} else { |
$pluriel_loc = ''; |
} |
if ($nb_total > 1) { |
$pluriel_tot = 's'; |
} else { |
$pluriel_tot = ''; |
} |
if ($tableau['pend'] > 0) { |
$add_from = $tableau['pstart'] + 1; |
$tmp_num = $tableau['pstart'] + $tableau['step']; |
if ($tmp_num < $tableau['pend']) { |
$add_to = $tmp_num; |
} else { |
$add_to = $tableau['pend']; |
} |
} |
switch ($modele) { |
case 'synth': |
$var_affiche .= '<strong>'.$nb_total.'</strong>'.' synthèse'.$pluriel_tot.' trouvée'.$pluriel_tot.'.'; |
if ($tableau['pend'] > 0) { |
$var_affiche .= ' Affichage des synthèses '.$add_from.' à '.$add_to.'.'; |
} |
break; |
case 'bbpopup': |
$feminin = ''; |
if ($tableau['feminin'] == 1) { |
$feminin = 'e'; |
} |
$var_affiche .= '<strong>'.$nb_total.'</strong>'.' '.$tableau['libelle'].$pluriel_tot.' trouvé'.$feminin.$pluriel_tot.'.'; |
if ($tableau['pend'] > 0) { |
$var_affiche .= ' Affichage des éléments '.$add_from.' à '.$add_to.'.'; |
} |
break; |
// Mise en forme par défaut : |
default: |
if ($tableau['pend'] > 0) { |
$var_affiche .= ' Affichage des données <strong>'.$add_from.'</strong> à <strong>'.$add_to.'</strong>'."\n"; |
} |
$var_affiche .= ' parmi '.'<strong>'.$tableau['pend'].'</strong>'.' résultat'.$pluriel_loc.'.'."\n"; |
break; |
} |
return $var_affiche; |
} |
/**Fonction FRAG_decoupageChaine() - Découpe une chaine. |
* |
* Cette fonction permet de découper la variable de tranfert $chaine et de réaffecter dans un tableau |
* les valeurs et les index. |
* |
* @param string chaine à désérialiser. |
* |
* @return array le tableau contenant les index et les valeurs de la chaine. |
*/ |
function FRAG_decoupageChaine($chaine) |
{ |
$chaine = eregi_replace('{', ' ', $chaine); |
$tableau_transfert = explode('!', $chaine); |
foreach ($tableau_transfert as $objet) { |
$objet_decoupe = explode(',', $objet); |
$objet_decoupe_1 = $objet_decoupe[0]; |
if ((!empty($objet_decoupe_1)) && (!empty($objet_decoupe[1]))) { |
$tableau_retour[$objet_decoupe_1] = $objet_decoupe[1]; |
} |
} |
return $tableau_retour; |
} |
/** |
//==================================== FUNCTION ================================== |
* La fonction rechercheAlphabet() renvoie une liste alphabétique. |
* |
*Cette fonction retourne une liste alphabétique et un tableau html contenant les résultats |
*d'une requête sql pour une lettre de l'alphabet donnée. |
*Quand on clique sur une lettre de la liste alphabétique la page est rechargée et la |
*fonction renvoie la liste et le tableau de résultat correspondant à la requête sql |
*avec la lettre de l'alphabet sélectionnée. |
* Elle nécéssite l'inclusion du fichier lib.form.php |
* |
*Le tableau associatif de formatage des lignes: |
*-clé "Class_pair": contient le nom d'une classe css à utiliser pour le |
* formatage des lignes de résultats paires. |
*-clé "Class_impair": contient le nom d'une classe css à utiliser pour le |
* formatage des lignes de résultats impaires. |
*-clé "Style_pair": contient les syles à utiliser pour le |
* formatage des lignes de résultats paires. |
*-clé "Style_impair": contient les syles à utiliser pour le |
* formatage des lignes de résultats impaires. |
*-clé "Couleur_pair": la valeur héxadécimale de la couleur des lignes |
* paires du tableau de résultats. |
*-clé "Couleur_impair": la valeur héxadécimale de la couleur des lignes |
* impaires du tableau de résultats. |
* Il est conseillé d'utilser les styles ou les |
* classes pour gérer la couleur. |
* |
*Le tableau associatif de formatage des résultats: |
*Nous stockons des tableaux associatifs dans le tableau de formatage. |
*Chaque ligne du tableau de formatage correspond à une colone, on doit |
*les entrer dans l'orde d'affichage. |
*-clé "Col_nom": chaine le nom du champ de la requête sql à afficher. |
*-clé "Col_width": entier largeur de la colone |
*-clé "Col_class": chaine nom de la classe css de la colone. |
*-clé "Col_lien_href": chaine l'url de base pour créer un lien sur la colone. |
*-clé "Col_lien_href_param": chaine nom du champ dans la requete SQL servant à compléter l'url. |
*-clé "Col_lien_target": chaine la valeur de l'attribut 'target'du lien. |
*-clé "Col_lien_class": chaine la valeur de l'attribut 'class'du lien. |
*-clé "Col_lien_title": chaine la valeur de l'attribut 'title'du lien. |
* |
*Exemple: |
*$tablo_formatResultat[0]=array( |
*"Col_nom"=>ENT_NOM_COMPLET, |
*"Col_width"=> 375, |
*"Col_class"=>'texte_tb2', |
*"Col_lien_href"=>'http://test.tela-botanica.org/', |
*"Col_lien_href_param"=>ENT_NUM_NOMEN, |
*"Col_lien_target"=>'_top', |
*"Col_lien_class"=>'eflore_lien', |
*"Col_lien_title"=>'Voir la fiche correspondante dans l\'index des plantes'); |
*$tablo_formatResultat[1]=array( |
*"Col_nom"=>ECS_INTITULE, |
*"Col_width"=> 75, |
*"Col_class"=>'texte_tb2 texte_c'); |
* |
* @param string une chaine fournissant la base de l'url de la page où la fonction est utilisée. |
* @param string la chaine correspondant aux paramètres à faire passer dans l'url. |
* @param string la requete sql qui fournira le tableau pour une lettre donnée. |
* @param string le code html d'ouverture du tableau entre la liste alphabétique et les lignes de résultat. |
* @param string le code html de fermeture du tableau aprés les lignes de résultat. |
* @param array un tableau associatif contenant le formatage des lignes |
* @param string le code html du message d'erreur s'il n'y a pas de lignes de résultat. |
* @return string le code html de la liste alphabétique et du tableaux de lignes de résultat. |
//============================================================================== |
*/ |
function FRAG_rechercherAvecAlphabet( $requete, $baseURL, $paramURL = '', $affichageResultAvt = '', $affichageResultAps = '', |
$tablo_formatLigne = array(), $tablo_formatResultat = array(), $messageErreur = '', |
$fragmenteur = array()) |
{ |
global $lettre;// Variable passée dans l'url contenant la lettre sélectionnée |
//Nous concaténons les valeurs de l'url : |
$url = $baseURL.$paramURL; |
//Nous initialisons les variables par défaut |
if($messageErreur == '') { |
$messageErreur = '<p>Pas de résultats affichable!</p>'; |
} |
if($affichageResultAvt == '') { |
$affichageResultAvt = '<!-- AVANT RÉSULTATS -->'; |
} |
if($affichageResultAps == '') { |
$affichageResultAps = '<!-- APRÈS RÉSULTATS -->'; |
} |
if (empty($tablo_formatLigne)) { |
$tablo_formatLigne['Couleur_pair'] = '#E8FFE5'; |
} |
if ( ! empty($fragmenteur) ) { |
if (!isset($GLOBALS['T_REPONSE'])) { |
$GLOBALS['T_REPONSE'] = ''; |
} |
//Nous définissons les valeurs par défaut du fragmenteur : |
isset($fragmenteur['nbre_ligne_page_defaut']) ? '' : $fragmenteur['nbre_ligne_page_defaut'] = 20; |
isset($fragmenteur['afficher_titre']) ? '' : $fragmenteur['afficher_titre'] = 1; |
isset($fragmenteur['titre']) ? '' : $fragmenteur['titre'] = 'Sélectionner le nombre de résultats à afficher par page'; |
isset($fragmenteur['tableau_choix_ligne_page']) ? '' : $fragmenteur['tableau_choix_ligne_page'] = array(10,'par 10',20,'par 20',50,'par 50'); |
isset($fragmenteur['modele_info']) ? '' : $fragmenteur['modele_info'] = ''; |
isset($fragmenteur['classe_css_titre']) ? '' : $fragmenteur['classe_css_titre'] = 'insTitle1'; |
isset($fragmenteur['classe_css_fragmenteur']) ? '' : $fragmenteur['classe_css_fragmenteur'] = 'real_fragmenteur'; |
isset($fragmenteur['classe_css_info']) ? '' : $fragmenteur['classe_css_info'] = 'insTitle1'; |
// Nous créons le fragmentateur : |
$mon_fragmenteur = new fragmenteur_session(); |
} |
//Nous ajoutons à l'url le nom de la variable lettre. |
$url .= '&lettre='; |
// Nous construisons le tableau d'affichage de la liste alphabétique |
$sortieTexte = '' ; |
$sortieTexte .= '<p id="real_info">'."\n". |
'<span>'. |
'Cliquer sur une lettre pour faire apparaitre la liste des taxons correspondante :'. |
'</span>'."\n". |
'</p>'."\n"; |
$sortieTexte .= '<p id="real_alphabet"><strong>'."\n"; |
// Nous écrivons toutes les lettres avec un lien. |
// Nous utilisons les caractères asci de l'alphabet situé entre les numéros 61 et 95. |
for ($num_asci = 65 ; $num_asci < 91 ; $num_asci++) { |
$caractere = chr($num_asci) ; |
$sortieTexte .= "\t".'<a class="lien_recherche_alpha" href="'.$url.$caractere.'">'.chr($num_asci).'</a> '."\n"; |
} |
$sortieTexte .= "\t".'<a href="'.$url.'tous">'.'Tous'.'</a>'."\n"; |
$sortieTexte .= '</strong></p>'."\n"; |
// Si une lettre est selectionnée : |
if (!empty($lettre)) {//la variable est récupérée directement de l'url |
//Nous redéfinissons l'url en ajoutant la valeur de la variable lettre : |
$url .= $lettre; |
$resultat = mysql_query($requete) or die('<b>Erreur</b>:<br/><b>Requete : </b>'.$requete.'<br/><b>Erreur mysql: </b>' .mysql_error()); |
$nbre_ligne_resultat_total = mysql_num_rows($resultat) ; |
if ($nbre_ligne_resultat_total != 0) { |
if ( ! empty($fragmenteur) ) { |
$mon_fragmenteur->setURL($url) ; |
$T_REPONSE = $mon_fragmenteur->getVariable('T_REPONSE'); |
if( $T_REPONSE == '') { |
$mon_fragmenteur->fixerLePas ($fragmenteur['nbre_ligne_page_defaut']); |
} |
$requete .= ' LIMIT '.$mon_fragmenteur->lireLeDebut().','.$mon_fragmenteur->lireLePas(); |
$resultat = mysql_query($requete) or die('<b>Erreur</b>:<br/><b>Requete : </b>'.$requete.'<br/><b>Erreur mysql: </b>' .mysql_error()); |
$nbre_ligne_resultat_affiche = mysql_num_rows($resultat) ; |
if ($fragmenteur['afficher_titre'] == 1) { |
$sortieTexte .= '<tr class="'.$fragmenteur['classe_css_titre'].'"><td colspan="2">' ; |
$sortieTexte .= $fragmenteur['titre']; |
$sortieTexte .= '</td></tr>'."\n" ; |
} |
$sortieTexte .= '<form id="real_page_quantite" action="'.$url.'" method="post">'."\n"; |
$sortieTexte .= '<p>'."\n"; |
$formulaire = new form($GLOBALS['_GEN_commun']['pear_db']); |
$javascript_select['nom_evenement'] = 'onchange'; |
$javascript_select['valeur_evenement'] = 'javascript:this.form.submit();'; |
$sortieTexte .= $formulaire->selectFromTableau('T_REPONSE', $fragmenteur['tableau_choix_ligne_page'], |
empty($T_REPONSE) ? $fragmenteur['nbre_ligne_page_defaut'] : $T_REPONSE, $javascript_select) ; |
$sortieTexte .= '</p>'."\n"; |
$sortieTexte .= '</form>'."\n"; |
$sortieTexte .= '<p id="real_nbre_resultat">'."\n". |
$mon_fragmenteur->affNbRes($nbre_ligne_resultat_total). |
'</p>'."\n"; |
$sortieTexte .= '<p class="'.$fragmenteur['classe_css_fragmenteur'].'">'."\n". |
$mon_fragmenteur->fragmente($nbre_ligne_resultat_total). |
'</p>'."\n"; |
} |
// Nous affichons les résutats de la requête avec une lettre donnée. |
$sortieTexte .= $affichageResultAvt; |
// Dans le cas de l'affichage par défaut, nous affichons les noms des colones : |
if (empty($tablo_formatResultat)) {//Dans le cas ou l'on utilise la fonction par défaut |
$sortieTexte .='<tr>'; |
for ($i=0; $i<mysql_num_fields($resultat); $i++) { |
$sortieTexte .= '<td>'.mysql_field_name($resultat, $i).'</td>'."\n"; |
} |
$sortieTexte .='</tr>'; |
} |
$pair = false ; |
$ligne = ''; |
while ($ligne = mysql_fetch_array($resultat)) { |
// Nous ouvrons la balise de début de ligne |
$sortieTexte .= '<tr '; |
// Nous colorions la ligne |
if ($pair) { |
isset($tablo_formatLigne['Class_pair'])?$sortieTexte .= 'class="'.$tablo_formatLigne['Class_pair'].'" ':'';// |
isset($tablo_formatLigne['Syle_pair'])?$sortieTexte .= 'style="'.$tablo_formatLigne['Syle_pair'].'" ':'';// |
isset($tablo_formatLigne['Couleur_pair'])?$sortieTexte .= 'bgcolor="'.$tablo_formatLigne['Couleur_pair'].'"':'';//La couleur dans Tela est #E8FFE5 |
$pair = false ; |
} |
else { |
isset($tablo_formatLigne['Class_impair'])?$sortieTexte .= 'class="'.$tablo_formatLigne['Class_impair'].'" ':'';// |
isset($tablo_formatLigne['Syle_impair'])?$sortieTexte .= 'style="'.$tablo_formatLigne['Syle_impair'].'" ':'';// |
isset($tablo_formatLigne['Couleur_impair'])?$sortieTexte .= 'bgcolor="'.$tablo_formatLigne['Couleur_impair'].'"':'';//La couleur dans Tela est #E8FFE5 |
$pair = true ; |
} |
$sortieTexte .= '>';// Nous fermons la balise de début de ligne |
// Nous affichons les résultats dans des colones |
if (empty($tablo_formatResultat)) {//Dans le cas ou l'on utilise la fonction par défaut |
for ($i=0; $i<(count($ligne)/2); $i++) { |
$sortieTexte .='<td>'.$ligne[$i].'</td>'."\n"; |
} |
} else {//Dans le cas ou l'on utilise un tableau de formatage |
for ($i = 0; $i < count($tablo_formatResultat); $i++) { |
if (isset($tablo_formatResultat[$i]['Col_lien_href'])){ |
isset($tablo_formatResultat[$i]['Col_lien_href_param'])?'':$tablo_formatResultat[$i]['Col_lien_href_param']=''; |
$sortieTexte .= '<td class="'.$tablo_formatResultat[$i]['Col_class']. |
'" width="'.$tablo_formatResultat[$i]['Col_width'].'">'. |
'<a href="'.$tablo_formatResultat[$i]['Col_lien_href']. |
$ligne[$tablo_formatResultat[$i]['Col_lien_href_param']]. |
'" target="'.$tablo_formatResultat[$i]['Col_lien_target']. |
'" title="'.$tablo_formatResultat[$i]['Col_lien_title']. |
'" class="'.$tablo_formatResultat[$i]['Col_lien_class'].'">'; |
//Nous regardons si la colonne du tableau HTML est composée de plusieurs |
//colonnes de la table de la base de données. |
if (! is_array($tablo_formatResultat[$i]['Col_nom']) ) { |
//Une seule colonne. |
$sortieTexte .= $ligne[$tablo_formatResultat[$i]['Col_nom']]; |
} else { |
//Plusieurs colonnes et/ou texte. |
$tab_contenu_colonne = $tablo_formatResultat[$i]['Col_nom']; |
for ($j = 0; $j < count($tab_contenu_colonne); $j++) { |
if ($tab_contenu_colonne[$j]['type'] == 'texte') { |
//Nous devons afficher du texte. |
$sortieTexte .= $tab_contenu_colonne[$j]['valeur']; |
} |
elseif ($tab_contenu_colonne[$j]['type'] == 'colonne') { |
//Nous devons afficher une valeur d'une colonne résultat de la requête SQL. |
$sortieTexte .= $ligne[$tab_contenu_colonne[$j]['valeur']]; |
} |
} |
} |
$sortieTexte .= '</a></td>'."\n"; |
} else { |
$sortieTexte .='<td class="'.$tablo_formatResultat[$i]['Col_class'].'" width="'.$tablo_formatResultat[$i]['Col_width'].'">'.$ligne[$tablo_formatResultat[$i]['Col_nom']]."</td>\n"; |
} |
} |
} |
$sortieTexte .= '</tr>'; |
} |
$sortieTexte .= $affichageResultAps; |
} |
else { |
// Nous affichons le message d'erreur signalant l'abscence de résultats. |
$sortieTexte .= $messageErreur; |
} |
} |
return $sortieTexte ; |
} |
/* +--Fin du code ---------------------------------------------------------------------------------------+ |
* $Log: FRAG_fragmenteur.fonct.php,v $ |
* Revision 1.6 2005/02/23 17:28:35 jpm |
* Suppression d'image dans le fragmenteur et remplacement par des styles css. |
* Amélioration du code html. |
* |
* Revision 1.5 2005/02/22 16:21:28 jpm |
* Mise à jour : utilisation des session, mise en forme et suppression d'appel de fichiers inutiles. |
* |
* Revision 1.4 2004/09/11 19:12:43 jpm |
* Début mise en forme. |
* |
* Revision 1.3 2004/09/11 15:37:02 jpm |
* Modification de l'inclusion de fichier. |
* |
* Revision 1.2 2004/09/10 15:03:41 jpm |
* Ajout de commentaires. |
* |
* |
* +--Fin du code ----------------------------------------------------------------------------------------+ |
*/ |
?> |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |