Codulle - L'explorateur de code sources

Accueil |
Albulle1.0rc2
Informations fichier

Nom du fichier : util.class.php
Taille du fichier : 27 Ko (730 lignes)
Language : PHP
span style="color: #808080; font-style: italic;">////////////////////////////////////////
// Encodage du fichier : UTF-8
// Utilisation des tabulations : Oui
// 1 tabulation = 4 caractères
// Fins de lignes = LF (Unix)
////////////////////////////////////////
 
///////////////////////////////
// LICENCE
///////////////////////////////
//
// © DUCARRE Cédric (SamRay1024), Bubulles Créations, (09/05/2005)
//
// webmaster@jebulle.net
// http://jebulle.net
//
// Ce fichier fait partie d'AlBulle, script de gestion d'albums photos.
//
// Ce logiciel est régi par la licence CeCILL soumise au droit français et
// respectant les principes de diffusion des logiciels libres. Vous pouvez
// utiliser, modifier et/ou redistribuer ce programme sous les conditions
// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
// sur le site "http://www.cecill.info".
//
// En contrepartie de l'accessibilité au code source et des droits de copie,
// de modification et de redistribution accordés par cette licence, il n'est
// offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
// seule une responsabilité restreinte pèse sur l'auteur du programme,  le
// titulaire des droits patrimoniaux et les concédants successifs.
//
// A cet égard  l'attention de l'utilisateur est attirée sur les risques
// associés au chargement,  à l'utilisation,  à la modification et/ou au
// développement et à la reproduction du logiciel par l'utilisateur étant
// donné sa spécificité de logiciel libre, qui peut le rendre complexe à
// manipuler et qui le réserve donc à des développeurs et des professionnels
// avertis possédant  des  connaissances  informatiques approfondies.  Les
// utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
// logiciel à leurs besoins dans des conditions permettant d'assurer la
// sécurité de leurs systèmes et ou de leurs données et, plus généralement,
// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
//
// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
// pris connaissance de la licence CeCILL, et que vous en avez accepté les
// termes.
//
///////////////////////////////
 
 
/**
 * Librairie de fonctions inclassables.
 *
 * @author SamRay1024
 * @copyright Bubulles Creation - http://jebulle.net
 * @since 31/10/2006
 * @version 1.6
 *
 *//**
	 * Redimensionner une image.
	 *
	 * @param	[RESOURCE]	$img_src		Contenu binaire de l'image à redimensionner.
	 * @param	[INTEGER]	$larg_mini_max	Largeur max de la redimension.
	 * @param	[INTEGER]	$haut_mini_max	Hauteur max de la redimension.
	 *
	 * @return	[RESOURCE]	Contenu binaire de l'image redimensionnée.
	 */// On recupere les dimensions de l'image que l'on souhaite redimensionner
// Cree une image vierge de la dimension desiree. Cette fonction permet de ne pas etre limite a 256 couleurs contrairement a "ImageCreate"
'largeur'], $aNouvellesDimensions['hauteur'] );
 
		// On effectue une copie de l'image source vers la miniture
'largeur'], $aNouvellesDimensions['hauteur'/**
	 * Calcul les nouvelles dimensions d'une image.
	 *
	 * @param	[INTEGER]	$iLargeurInitiale		Largeur initiale de l'image.
	 * @param	[INTEGER]	$iHauteurInitiale		Hauteur initiale de l'image.
	 * @param	[INTEGER]	$iLargeurDemandee		Largeur finale souhaitée.
	 * @param	[INTEGER]	$iHauteurDemandee		Hauteur finale souhaitée.
	 * @return	[ARRAY]								Retourne un tableau associatif qui contient les nouvelles dimensions.
	 * 													$aResultat['largeur'] & $aResultat['hauteur']
	 */'largeur' => 0, 'hauteur' => 0 );
 
		// si l'image est plus petite que les dimensions demandees, on ne redimensionne pas.
		// Pour cela, on force la valeur de la dimension souhaitee a la valeur de la taille de l'image
		// de sorte a creer un ratio de 1 pour la dimension
// On calcule le ratio pour la largeur et la hauteur
		$fRatioLargeur = $iLargeurDemandee / $iLargeurInitiale;
		$fRatioHauteur = $iHauteurDemandee / $iHauteurInitiale;
 
		// Et on garde le plus petit afin de ne jamais depasser la taille maximale
		$fRatioFinal = ( $fRatioLargeur <= $fRatioHauteur ) ? $fRatioLargeur : $fRatioHauteur;
 
		// Connaissant le ratio de la miniature, on peut donc obtenir ses dimensions reelles.
		// Ici, on utilise la fonction "round" pour avoir une valeur entiere. Cela nous donne le nombre de pixels que va faire la miniature.
		$aResultat['largeur''hauteur'/**
	 * Traitement d'une image postée par formulaire pour écriture dans un dossier.
	 *
	 * Adaptee de http://lecyber.net
	 *
	 * Cette méthode permet de traiter une image envoyée par un formulaire. L'image est redimensionnée aux dimensions
	 * souhaitées (uniquement si elle est plus grande que les dimensions demandées), écrite dans le dossier demandé
	 * et son nom de fichier peut être préfixé.
	 *
	 * @param	[STRING]	$type				Type MIME de l'image envoyée (ie : 'image/gif', 'image.jpg', ...).
	 * @param	[STRING]	$srcFile			Chemin d'accès complet à l'image que l'on souhaite redimensionner.
	 * @param	[STRING]	$destFile			Répertoire de destination de stockage de l'image redimensionnée.
	 * @param	[STRING]	[$larg_mini_max]	Largeur max de la miniature.
	 * @param	[STRING]	[$haut_mini_max]	Lauteur max de la miniature.
	 * @param	[STRING]	[$prefixe]			Si ce champ est indiqué, on génère une miniature préfixé de la chaîne que contient cette variable
	 *											sinon, on écrase le fichier d'entrée si le dossier de destination est le même que celui de l'image originale.
	 * @param	[INTEGER]	[$iQualite]			Uniquement pour les images Jpeg : permet de régler la qualité des miniatures sur une échelle de 0 à 100.
	 * 												75 : par défaut
	 * 												0 : mauvaise qualité, petit fichier
	 * 												100 : meilleure qualité, gros fichier
	 * @return	[STRING]						Chemin d'accès à la miniature qui vient d'être générée.
	 */'', $iQualite = 75 )
	{
 
		// Recuperation des infos du fichier de destination
// chemin d'acces
// nom du fichier
 
		// on reecrit le fichier de destination avec le prefixe et le chemin complet
'/'// creation de l'image en fonction du type MIME
'image/pjpeg''image/jpeg''image/x-png''image/png''image/gif'// si les deux longeurs max sont nulles, alors on ne redimensionne pas l'image
// Si un second parametre est indique a la fonction ImageJpeg, la miniature est sauvegardee mais elle ne sera pas affichee. Ex : ImageJpeg( $img_src, './miniatures/mini.jpg');
'image/pjpeg''image/jpeg':
				// ecriture de la miniature au format jpeg
'image/x-png''image/png':
				// ecriture de la miniature au format png
'image/gif':
				// ecriture de la miniature au format gif
// destruction du tampon de l'image
/**
	 * Méthode avancée de lecture de dossiers.
	 *
	 * La méthode reçoit un chemin de dossier, ouvre ce dossier et en donne la liste des éléments, qui
	 * peuvent être ou les dossiers, ou les fichiers, ou les deux.
	 *
	 * Les éléments lus du dossiers sont retournés dans un tableau de deux manières différentes. Pour
	 * les cas où soit les dossiers, soit les fichiers sont demandés, le tableau retourné est un tableau
	 * indexé classique à une dimension. En revanche pour le cas ou les deux types sont demandés, le tableau
	 * retourné est un tableau à deux dimensions. La 1ère est associative et contient deux sous-tableaux :
	 * l'un pour les dossiers, l'autre pour les fichiers.
	 *
	 * 		$aTableauRetour['dir'] contient les dossiers lus.
	 * 		$aTableauRetour['file'] contient les fichiers lus.
	 *
	 * Les deux sous tableaux sont eux indexés classiquement, tout comme les tableaux de retour sur l'un
	 * ou l'autre des types demandés (dossiers/fichiers).
	 *
	 * @param	[STRING]	$sDir				Chemin du dossier à parcourir.
	 * @param	[STRING]	$sMode				Modes de parcours du dossier :
	 * 												'DOSSIERS_SEULEMENT'	=> retourne uniquement les dossiers.
	 * 												'FICHIERS_SEULEMENT'	=> retourne uniquement les fichiers.
	 * 												'TOUT'					=> retourne tous les éléments (dossiers ET fichiers).
	 * @param	[ARRAY]		$aFiltresDossiers	Optionnel. Tableau de dossiers qui ne doivent pas être pris en compte.
	 * @param	[ARRAY]		$aFiltresExtensions	Optionnel. Tableau à utiliser pour ne garder que les fichiers qui correspondent
	 * 												aux extensions données.
	 * 												Les extensions doivent être de la forme 'jpg', 'gif', 'exe', ...
	 * @return	[MIXED]							FALSE en cas d'erreur, tableau des éléments lus sinon.
	*/// creation du tableau qui va contenir les elements du dossier
// ajout du slash a la fin du chemin s'il n'y est pas
"/^.*\/$/"'/';
 
		// Ouverture du repertoire demande
// si pas d'erreur d'ouverture du dossier on lance le scan
// Parcours du repertoire
'.' && $sItem != '..'// Extraction de l'extension si filtrage sur extensions demandé
'.'// Ajout si autorisé
// Fermeture du repertoire
// Tri des dossiers
// construction tableau retour
'DOSSIERS_SEULEMENT''FICHIERS_SEULEMENT''TOUT''dir''file'/**
	 * Génération d'une liste de liens pour faire une pagination.
	 *
	 * Cette méthode est une adaptation de celle fourni dans PunBB, le
	 * script de forums.
	 *
	 *  ****
	 *  Copyright (C) 2002-2005  Rickard Andersson (rickard@punbb.org)
	 *
	 *  This function is part of PunBB.
	 *
	 *  PunBB is free software; you can redistribute it and/or modify it
	 *  under the terms of the GNU General Public License as published
	 *  by the Free Software Foundation; either version 2 of the License,
	 *  or (at your option) any later version.
	 *
	 *  PunBB 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 General Public License for more details.
	 *
	 *  You should have received a copy of the GNU General Public License
	 *  along with this program; if not, write to the Free Software
	 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	 *  MA  02111-1307  USA
	 *  ****
	 *
	 * @param	[INTEGER]	$num_pages		Le nombre de pages total.
	 * @param	[INTEGER]	$cur_page		La page courante.
	 * @param	[STRING]	$link_to		La destination des url qu'il faut placer dans les liens.
	 * @return	[STRING]	Retourne la liste des liens au format HTML.
	 */// If $cur_page == -1, we link to all pages (used in viewforum.php)
'<span class="pageActive">1</span>''<a href="''&amp;page=1" class="page">1</a>''<span>&hellip;</span>';
			}
 
			// Don't ask me how the following works. It just does, OK? :-)
'<a href="''&amp;page=''" class="page">''</a>''<span class="pageActive">''</span>''<span>&hellip;</span>';
 
				$pages[] = '<a href="''&amp;page=''" class="page">''</a>'/*'&#160;'*/'', $pages);
	}
 
	/**
	 * Extraire à gauche de la n-ième sous-chaîne.
	 *
	 * Extrait d'une chaine tout ce qui se trouve à gauche de la n-ième sous-chaine
	 * spécifiée. Par exemple, pour extraire les chemins parents dans une chaine de
	 * caractères qui contient un chemin :
	 * 		echo SousChaineGauche( 'dossier1/dossier2/dossier3/dossier4', '/', 2 );
	 * 		=> Affiche : dossier1/dossier2
	 *
	 * @param	[STRING]	$sChainePrincipale	La chaine dans laquelle on doit faire l'extraction.
	 * @param	[STRING]	$sSousChaine		La chaine à repérer.
	 * @param	[INTEGER]	$iNbOccurences		Le nombre d'occurences à partir duquel on garde ce qui se trouve
	 *											à gauche de la sous-chaine.
	 * @return	[STRING]						Retourne $sChainePrincipale tronquée.
	 */''/**
	 * Extraire à droite de la n-ième sous-chaîne.
	 *
	 * Extrait d'une chaine tout ce qui se trouve à droite de la n-ième sous-chaîne
	 * spécifiée. Par exemple, pour extraire les dossiers enfants dans une chaîne de
	 * caractères qui contient un chemin :
	 * 		echo sousChaineDroite( 'dossier1/dossier2/dossier3/dossier4', '/', 2 );
	 * 		=> Affiche : dossier3/dossier4
	 *
	 * @param	[STRING]	$sChainePrincipale	La chaine dans laquelle on doit faire l'extraction.
	 * @param	[STRING]	$sSousChaine		La chaine à repérer.
	 * @param	[INTEGER]	$iNbOccurences		Le nombre d'occurences à partir duquel on garde ce qui se trouve
	 *											à droite de la sous-chaine.
	 * @return	[STRING]						Retourne $sChainePrincipale tronquée.
	 */''/**
	 * Nettoyer une chaine de chemin d'accès qui provient d'une URL.
	 *
	 * Cette méthode permet le nettoyage d'une chaine qui représente un chemin vers un dossier quelconque.
	 * Elle est destinée à eviter les failles d'accès à des dossiers interdits par une URL. Elle se charge
	 * donc de repérer les dossiers vides ('//'), les noms tels './' et '../'. En plus, il est possible
	 * de demander à la méthode d'interdire des dossiers spécifiques dont vous passez le nom par
	 * l'intermédiaire d'un tableau.
	 *
	 * La chaine étant passée par référence, elle n'est pas retournée par la méthode et est directement
	 * utilisable dans le fichier appelant.
	 *
	 * @param	[STRING]	$sChaine				Passée par référence, la chaine est nettoyée des dossiers interdits.
	 * @param	[ARRAY]		$aDossiersInterdits		Optionnel. Contient une liste de dossiers interdits.
	 * @return	[ARRAY]								Retourne la chaine d'accès sous forme de tableau (pour des traitements ultérieurs)
	 */'';
 
		// On eclate le chemin dans un tableau extraire chaque dossier
'/', $sChaine );
 
		// on calcul le nombres de dossiers passés dans l'url
// Si des dossiers sont interdits, on construit la fin de l'expression régulière
'|'// nettoyage des dossiers, pour enlever les chaines vides, les accès du type ./ et ../
		// et les dossiers interdits
'''/^[.]+$''/'// reconstruction des index du tableau (utilisation d'un tableau vide pour corriger un bogue intervenant occasionnellement)
// Reconstruction de la chaine d'accès nettoyée
'/'/**
	 * Prépare un chemin d'accès à un fichier pour être utilisé comme Url (href ou src).
	 *
	 * @param	[STRING]	$sUrl			Le chemin à formater.
	 * @param	[BOOLEAN]	$bSansSlashs	Si True, les slashs ne seront pas encodés.
	 * @return	[STRING]					L'Url formatée.
	 */'%2F', '/', $sUrl ) : $sUrl;
	}
 
	/**
	 * Enlèver le préfixe d'une chaine.
	 *
	 * Permet d'effacer tout ce qui se trouve avant un séparateur dans une chaine.
	 * Le séparateur est lui aussi effacé. Si des espaces se trouvent après le séparateur,
	 * ils sont de même supprimés.
	 *
	 * @param	[STRING]	$sChaineANettoyer		La chaîne dans laquelle enlever un préfixe.
	 * @param	[STRING]	$sMarqueur				La chaîne qui marque la fin du préfixe.
	 * @return	[STRING]							La chaîne nettoyées.
	 */// Recherche du séparateur
// Extraction de ce qui ce trouve à gauche de la position trouvée
// Si la chaine lue à gauche du séparateur est bien un entier, on peut alors l'enlever
		// car on est certain qu'il représente le préfixe.
/**
	 * Parse un fichier pour remplacer ses pseudos-variables.
	 *
	 * Le tableau à passer en paramètres doit être associatif. Les clés de ce tableau doivent
	 * représenter les éléments à remplacer dans le fichier. Ces clés doivent alors être des
	 * expression régulières.
	 *
	 * De plus, le tableau peut être soit à une dimension soit à deux. Un tableau à une dimension
	 * signifie que vous parsez un fichier simple. Un tableau à deux dimensions signifie que
	 * vous devez parser le fichier autant de fois qu'il y a de valeurs dans la première dimension.
	 *
	 * En d'autres termes, le remplacement de données dans un fichier simple conduit à présenter un
	 * tableau de la façon suivante :
	 * 		$aElements['/{MON_ELEMENT_1}/']	= 'ce qui va être mis à la place';
	 * 		...
	 *
	 *  Et pour boucler sur le fichier :
	 *  	$aElements[0]['/{MON_ELEMENT_1}/']	= 'ce qui va être mis à la place';
	 *  	$aElements[0]['/{MON_ELEMENT_2}/']	= '...';
	 *  	...
	 *  	$aElements[1]['/{MON_ELEMENT_1}/']	= '...';
	 *  	$aElements[1]['/{MON_ELEMENT_2}/']	= '...';
	 *  	...
	 *
	 * /!\ Si le tableau passé en paramètre est à deux dimensions, il faut définir le dernier
	 * paramètre à True.
	 *
	 * @param	[String]	$sCheminFichier			Le chemin d'accès au fichier à parser.
	 * @param	[String]	$aElementsARemplacer	Le tableau dont les clés sont les expressions régulières d'accès aux pseudo-variables
	 * 												et les valeurs le contenu à remplacer.
	 * @param	[Boolean]	$bBoucler				Optionnel. Si vrai, c'est que le tableau est bi-dimensionnel, donc qu'il s'agit de boucler
	 * 												sur plusieurs éléments.
	 * @return	[String]							Le contenu du fichier parsé.
	 */// Lecture fichier et remplacement des pseudos-variables
// Extraction des patterns à remplacer
''/**
	 * Créé une liste HTML dont chaque puce représente une information EXIF d'une image au format JPEG.
	 *
	 * Les informations retournées par cette méthode sont les suivantes :
	 * 		Marque et modèle de l'appareil photo, date et heure de la photo, temps d'exposition,
	 * 		sensibilité ISO, ouverture et longueur de la focale.
	 *
	 * @param	[STRING]	$sCheminImage	Le chemin d'accès à l'image dont on souhaite obtenir les infos EXIF.
	 * @return	[STRING]					Si la photo ne possède pas de données EXIF, une simple phrase est retournée. Sinon
	 * 										la méthode retourne une liste <ul>...</ul> avec un élément <li>...</li> par donnée.
	 * 										La liste <ul> possède un identifiant, "exif", pour repérer la liste avec une feuille
	 * 										de style CSS.
	 */"<ul id=\"exif\">\n\t"'inconnue''exif_imagetype''ANY_TAG''IFDO'// Marque appareil
'<li><span>Marque de l\'appareil : </span>''Make''IFD0''IFD0']['Make'] !== '''IFD0']['Make''</li>';
 
						// Modèle appareil
'<li><span>Modèle de l\'appareil : </span>''Model''IFD0''IFD0']['Model'] !== '''IFD0']['Model''</li>''EXIF'// Date/heure
'<li><span>Date/Heure de la prise de vue : </span>''DateTimeOriginal''EXIF''EXIF']['DateTimeOriginal'] !== '''EXIF']['DateTimeOriginal''</li>';
 
						// Temps exposition
'<li><span>Temps d\'exposition : </span>''ExposureTime''EXIF''EXIF']['ExposureTime'] !== '''EXIF']['ExposureTime''</li>';
 
						// ISO
'<li><span>Sensibilité ISO : </span>''ISOSpeedRatings''EXIF''EXIF']['ISOSpeedRatings'] !== '''EXIF']['ISOSpeedRatings''</li>';
 
						// Longueur focale
'<li><span>Longueur de la focale : </span>''FocalLength''EXIF''EXIF']['FocalLength'] !== '''EXIF']['FocalLength''</li>''COMPUTED'// Ouverture focale
'<li><span>Ouverture de la focale : </span>''ApertureFNumber''COMPUTED''COMPUTED']['ApertureFNumber'] !== '''COMPUTED']['ApertureFNumber''</li>'''''''"</ul>\n"/**
	 * Tronque la chaîne de catactères passée en paramètre pour la réduire à iNbCaracteres.
	 * La chaine est complétée avec '...' pour indiquer qu'elle n'est pas complète.
	 *
	 * @param	[STRING]	$sChaineATronquer	La chaîne que l'on souhaite tronquer.
	 * @param	[STRING]	$iNbCaracteres		Le nombres de caractères maximals que doit faire la chaine depuis le début.
	 * @return	[STRING]						La chaîne tronquée + '...'.
	 */'...''';
	}
 
	/**
	 * Lit le type MIME d'une image.
	 *
	 * La fonction fonctionne de deux façons différentes :
	 *  - si les extensions pour le support EXIF sont chargées : utilisation de la fonction exif_imagetype.
	 * 		Tous les formats d'images sont alors supportés.
	 * 	- si les extensions ne sont pas chargées : code perso qui lit l'extension du fichier pour en déterminer
	 *      le type MIME. Seul sont détectées les jpg, gif et png.
	 *
	 * Les valeurs de retour possibles sont les suivantes :
	 * 	- image/jpeg
	 *  - image/gif
	 *  - image/png
	 *
	 * @param	[STRING]	$sCheminImg		Chemin d'accès au fichier dont on veut le type MIME.
	 * @return	[STRING]					Type MIME.
	 */'exif_imagetype''.''jpg''jpeg''jpe': $sTypeMime = 'image/jpeg''gif': $sTypeMime = 'image/gif''png': $sTypeMime = 'image/png'
Codulle - L'explorateur de code sources

Informations fichier

Liste des projets

Publié par Codulle - v0.1.1 - © Bubulles Creations
