Forum d'entraide PHPFrance

$up = new Telechargement('Documents','form1','doc');

$extensions = array('pdf','txt');

$up->Set_Extensions_accepte ($extensions);

$up->Upload('reload');

<?php require('class_upload.php');

$up = new Telechargement('Documents','form1','doc');

$extensions = array('pdf','txt');
$up->Set_Extensions_accepte ($extensions);

$up->Upload('reload');
?>
<form enctype = "multipart/form-data" action = "#" method = "post">	  
<input name = "doc" type = "file" size = "70" />				 
<input type = "submit" name = "form1" value = "Envoyez"  />	
</form>

$up = new Telechargement('Documents','form1','doc');

$up->Set_Controle_dimImg ();

$up->Upload('reload');

$up = new Telechargement('Documents','form1','doc');

$up->Set_Redim ('600','500');

$up->Upload('reload');

UTILISATION DE LA CLASSE


A/ INITIALISATION DE LA CLASSE

L'initialisation de la classe "Telechargement" requière trois paramètres indispensables, les quatrième et cinquième étant facultatifs

1/ le nom du répertoire de destination par rapport à la racine du site.

2/ Nom de l'input d'identification et de contrôle d'envoi du formulaire (ex : input de type hidden).

3/ Nom de l'input de type file de votre formulaire. Ce nom peut désigner un tableau pour l'envoi simultané de plusieurs fichiers.

4/ Nom de la variable $_GET de contrôle d'envoi du formulaire (variable $_GET dans l'attribut "action" de la balise "form").

5/ Tableau de messages pour personnaliser ou traduire les messages d'informations de résultat.

$var = new Telechargement('répertoire','input_hidden','userfile','get_action_form',$tab_infos);


Notes :

- Le répertoire de destination doit être indiqué par rapport à la racine www. Si vous testez en local avec plusieurs sites installés sur la racine du serveur d'évaluation (dans le répertoire www) vous devrez indiquer pour un chemin de répertoire valide :

nom_du_repertoire_du_site/nom_du_repertoire_du_dossier

et pour un fonctionnement sur le serveur distant, simplement :
nom_du_repertoire_du_dossier

L'avantage de cette configuration est que vous pouvez appeler ce script depuis n'importe quel endroit de votre site sans avoir à modifier le chemin des répertoires de destination.


- Le paramètre n°2 identifie le formulaire. Par conséquent ce paramètre doit être différent pour chaque formulaire si vous avez plusieurs formulaires d'envoi de fichiers dans une même page.

- Si le quatrième paramètre n'est pas renseigné ou erroné il n'y aura pas de message pour indiquer un éventuel dépassement de la taille maximum du $_POST autorisée par le serveur. Il est donc recommandé de le renseigner pour une gestion complète des erreurs.

- Le cinquième paramètre facultatif, destiné à recevoir un tableau de personnalisation ou de traduction des messages d'information de résultat, peut être alternativement renseigné par la fonction "Set_Tab_messages" (voir paragraphe H/). Mais il est recommandé de le renseigner ici comme cinquième paramètre lors de l'initialisation de la classe, sans quoi le message de dépassement de la taille maximum du $_POST autorisée par le serveur prendra la valeur de l'élément du tableau interne de la classe et non celui du tableau externe personnalisé ou traduit.
Pour plus d'infos sur les possibilités de personnalisation de ce tableau, voir le paragraphe H/




B/ CONTROLE DES EXTENSIONS DE FICHIERS

Par sécurité, l'emploi de la fonction "Set_Extensions_accepte", dans laquelle vous transmettez en paramètre un tableau d'extensions autorisées, est indispensable excepté si vous utilisez la fonction "Set_Controle_dimImg" de contrôle des images ou si vous utilisez la fonction "Set_Redim" de redimensionnement des images (ces deux fonctions contrôlant déjà que le fichier est une image de type jpg ou jpeg ou png ou gif).

Si vous souhaiter ne pas contrôler les extensions des fichiers (à éviter pour des raisons de sécurité), transmettez un tableau vide en paramètre.

Exemple pour limiter le téléchargement aux fichiers d'extension jpg ou jpeg :

$tab_extensions_autorisees = array('jpg','jpeg');

$var->Set_Extensions_accepte($tab_extensions_autorisees);




C/ CONTROLE DES IMAGES

L'emploi de la fonction "Set_Controle_dimImg" est facultative. Elle vérifie que le fichier est effectivement une image de type gif, png, jpg ou jpeg et retourne ses dimensions dans le tableau des résultats. Si le fichier n'est pas une image, il ne sera pas téléchargé. Par sécurité, utilisez cette fonction pour un téléchargement d'images (excepté si vous utilisez la fonction "Set_Redim" qui effectue les mêmes contrôles).

$var->Set_Controle_dimImg();




D/ CONTROLE ANTI ECRASEMENT

L'emploi de la fonction "Set_Controle_fichier" est facultative. Si vous l'employez, les fichiers téléchargés ayant un nom de fichier identique dans le répertoire de destination, renverront simplement un message "ce fichier existe déjà" et aucune autre action ne sera engagée. Si la vérification ne trouve pas de fichier de nom identique dans le répertoire de destination, le fichier sera téléchargé.

$var->Set_Controle_fichier();




E/ RENOMMAGE AUTOMATIQUE DES FICHIERS

L'emploi de la fonction "Set_Renomme_fichier" est facultative. Si vous l'employez, les fichiers téléchargés ayant un nom de fichier identique dans le répertoire de destination, seront renommés et téléchargés. Cette fonction peut prendre un paramètre optionnel constitué de tout caractère ou chaine de caractères non nulle, pour indiquer un renommage avec un suffixe incrémentiel plutôt qu'un renommage avec un suffixe unique (qui est le fonctionnement par défaut).

$var->Set_Renomme_fichier();
ou
$var->Set_Renomme_fichier('incr');

Cette fonction peut être combinée avec la fonction "Set_Nomme_fichier"


Notes :

- Si vous avez beaucoup de fichiers dans votre répertoire, préférez la fonction "Set_Renomme_fichier" dans sa configuration avec un suffixe unique (configuration par défaut) car la configuration incrémentielle sera d'autant plus gourmande en ressource mémoire et d'autant moins performante que le nombre de fichiers susceptibles d'avoir un nom identique sera important (mais suffisamment rapide pour un usage courant).

- Si vous n'employez aucune des deux fonctions "Set_Controle_fichier" ou "Set_Renomme_fichier", les fichiers ayant sur le serveur un nom identique au fichier téléchargé seront écrasés. Si vous employez les deux, la fonction "Set_Controle_fichier" sera la seule prise en compte.

- En cas d'emploi d'une de ces deux fonctions conjointement avec la fonction de redimension des images "Set_Redim" détaillée ci-dessous, la vérification d'une image déjà existante de même nom se fait uniquement dans le répertoire déclaré dans l'initialisation de la classe afin de préserver la cohérence des données entre les différents répertoires de destination.




F/ IMPOSER UN NOM DE DESTINATION

L'emploi de la fonction "Set_Nomme_fichier" est facultative. Elle sert à imposer un nom pour le fichier en téléchargement et peut prendre trois paramètres, les deux derniers constitués de tout caractère ou chaine de caractères non nulle étant optionnels :

1/ Le nom de destination avec ou sans extension

2/ Permet d'indiquer que le nom de destination peut prendre l'extension du fichier téléchargé (évidemment dans ce cas indiquez comme premier paramètre un nom sans extension)

3/ Permet d'indiquer à la fonction, dans le cas où le nom indiqué en premier paramètre est non valide, que le message d'erreur doit être reporté dans le tableau des messages d'information et non pas comme une erreur webmestre (qui est le comportement par défaut).

$var->Set_Nomme_fichier('ma_photo.jpg');
ou
$var->Set_Nomme_fichier('ma_photo','ext_fichier_telecharge');
ou
$var->Set_Nomme_fichier('ma_photo','ext_fichier_telecharge','erreur_mes_info');

Bien entendu vous pouvez utiliser cette fonction conjointement avec la fonction "Set_Renomme_fichier". Par exemple si vous avez trois champs de téléchargement :

$var->Set_Renomme_fichier('incr');
$var->Set_Nomme_fichier('ma_photo_8.jpg');

ce code permettra de nommer le premier fichier "ma_photo_8.jpg", le second "ma_photo_9.jpg" et le troisième "ma_photo_10.jpg"




G/ REDIMENSIONNER, OPTIMISER DES IMAGES

L'emploi de la fonction "Set_Redim" est facultative et permet un ou plusieurs redimensionnements d'images. Elle accepte 5 paramètres tous optionnels :

1/ Largeur maximale de l'image redimensionnée en pixels

2/ Hauteur maximale de l'image redimensionnée en pixels

3/ Répertoire de destination (si non renseigné, prend la valeur du répertoire indiqué dans l'initialisation de la classe)

4/ Qualité du redimensionnement, en pourcentage de 1 à 100. Plus la qualité est importante, plus les fichiers seront lourds. La qualité par défaut est de 88 soit le maximum "raisonnable". Au delà de ce seuil les fichiers deviennent très lourds sans gain significatif de qualité.

5/ Paramètre quelconque constitué de tout caractère ou chaine de caractères non nulle pour permettre un redimensionnement supérieur au dimensions de l'image originale (agrandissement).

Exemples de configurations :

a/ Fichier redimensionné en 900 pixels de largeur maximum, 800 pixels de hauteur maximum et téléchargé dans le répertoire indiqué dans l'initialisation de la classe.

$var = new Telechargement('PHOTO','input_hidden','userfile','get_action_form');

$var->Set_Redim('900','800');

$var->Upload('reload');

(fichier redimensionné et téléchargé dans le répertoire "PHOTO")


b/ Si le répertoire indiqué en troisième paramètre de la fonction "Set_Redim" est différent de celui indiqué dans l'initialisation de la classe, l'image originale (sans traitement) sera téléchargée dans le répertoire indiqué dans l'initialisation de la classe et un second fichier rédimensionné sera téléchargé dans ce répertoire.

$var = new Telechargement('PHOTO','input_hidden','userfile','get_action_form');

$var->Set_Redim('900','800', 'PHOTO_GF');

$var->Upload('reload');

(fichier original téléchargé dans le répertoire "PHOTO" + fichier redimensionné en max 900 x 800 téléchargé dans le répertoire "PHOTO_GF")


A noter que l'on peut utiliser plusieurs fois la fonction "Set_Redim"

$var = new Telechargement('PHOTO','input_hidden','userfile','get_action_form');

$var->Set_Redim('900','800', 'PHOTO_GF');

$var->Set_Redim('150','150', 'PHOTO_PF');

$var->Upload('reload');

(fichier original téléchargé dans le répertoire "PHOTO" + fichier redimensionné en max 900 x 800 téléchargé dans le répertoire "PHOTO_GF" + fichier redimensionné en max 150 x 150 téléchargé dans le répertoire "PHOTO_PF")

ou encore

$var = new Telechargement('PHOTO_GF','input_hidden','userfile','get_action_form');

$var->Set_Redim('900','800');

$var->Set_Redim('150','150', 'PHOTO_PF');

$var->Upload('reload');

(fichier redimensionné en max 900 x 800 téléchargé dans le répertoire "PHOTO_GF" + fichier redimensionné en max 150 x 150 téléchargé dans le répertoire "PHOTO_PF")


Notes :

- Formats d'images acceptés pour le redimensionnement : gif, png, jpg, jpeg.

- Les images sont redimensionnées proportionnellement à leur taille originale. Par défaut les images de plus petites dimensions que celles indiquées dans la fonction "Set_Redim" ne sont pas agrandies mais simplement optimisées (compressées) pour le web. Vous pouvez modifier ce comportement (cf. fin de ce paragraphe).

- Pour un redimensionnement vous pouvez omettre de renseigner un des deux paramètres largeur max ou hauteur max ex:

$var->Set_Redim('','800');

(hauteur max 800 pixels. La largeur sera calculée en proportion des dimensions de l'image mais sans largeur maximale prédéfinie)

- Si vous n'indiquer aucun des deux paramètres "largeur max" et "hauteur max" la photo ne sera pas redimensionnée mais simplement optimisée (compressée) pour le web avec la qualité par défaut de 88% :

$var->Set_Redim();


- Si vous souhaitez un autre indice de qualité pour avoir par exemple des fichiers moins lourds, renseignez le quatrième paramètre :

$var = new Telechargement('PHOTO','input_hidden','userfile','get_action_form');

$var->Set_Redim('','','','75');

$var->Upload('reload');

(optimisation avec une qualité de 75%, pas de redimensionnement et fichier téléchargé dans le répertoire "PHOTO")


- Un cinquième paramètre optionnel (constitué de n'importe qu'elle chaine de caractères non nulle) permet d'autoriser un agrandissement de l'image si le fichier original a des dimensions plus petites que la largeur max et la hauteur max spécifiées dans la fonction :

$var = new Telechargement('PHOTO','input_hidden','userfile','get_action_form');

$var->Set_Redim('150','150','PHOTO_PF','85','A+');

$var->Upload('reload');

(fichier original téléchargé dans le répertoire "PHOTO" + fichier redimensionné avec une hauteur et une largeur max de 150 pixels et téléchargé dans le répertoire "PHOTO_PF" avec une qualité de 85%.
J'ai indiqué "A+" en cinquième paramètre (j'aurais pu indiquer "toto", peu importe) pour indiquer à la fonction de redimensionnement qu'elle pouvait agrandir des images de plus petites dimensions que 150 x 150 pixels jusqu'à 150 x 150 pixels. N'utilisez cette option qu'en connaissance de cause : les agrandissements peuvent donner des résultats moyens (ou moins suivant le coefficient de redimensionnement).


Important : Une fonction interne vérifie que les images en téléchargement peuvent être redimensionnées sans dépasser la mémoire disponible allouée par le serveur pour vos scripts. Cette fonction ne teste que les fichiers de types jpg ou jpeg. A noter que cette fonction utilise la fonction "memory_get_usage" qui doit être activée sur votre serveur sinon la vérification ne se fait pas.
Les fichiers de type png ou gif de trop grande résolution pour pouvoir être redimensionnés renverront une page vide sans message d'avertissement. Pour éviter cette éventualité dans le cas de fichiers à redimensionner, limitez si possible le format des images en téléchargement aux formats jpg et jpeg en utilisant la fonction "Set_Extensions_accepte" évoquée au paragraphe B /.




H/ TRADUCTION OU PERSONNALISATION DES MESSAGES D'INFORMATIONS

L'emploi de la fonction "Set_Tab_messages" est facultative et permet de personnaliser et/ou de traduire le tableau des messages d'information dans une autre langue. Elle accepte donc comme paramètre un tableau qui doit correspondre au tableau "private $tab_mes" de la classe de téléchargement. Alternativement pour bien visualiser ce tableau vous pouvez envoyer la fonction sans paramètre ce qui affichera un message d'erreur vous indiquant le tableau de correspondance demandé.

A noter que le deuxième élément (index 1) du tableau contenant le libellé : "téléchargé dans le dossier", est indispensable pour avoir un renseignement complet sur le résultat du téléchargement en cas de succès, à savoir : nom du fichier original + éventuellement nouveau nom en cas de renommage + éventuellement nouvelles dimensions de l'image en cas de redimensionnement + dossier de destination. Ces informations détaillées sont utiles pour un téléchargement de fichiers dans un espace administrateur. Cependant pour permettre un renseignement plus sommaire destiné aux visiteurs vous pouvez remplacer ce deuxième élément du tableau ("téléchargé dans le dossier") par une chaine vide ( '' ) auquel cas c'est le dernier élément du tableau "téléchargement OK" qui sera renvoyé à la place des informations détaillées.

$var->Set_Tab_messages(); (uniquement pour visualiser le tableau à personnaliser ou à traduire en phase de développement)

$var->Set_Tab_messages($tableau_personnalisé_ou_traduit); (paramétrage normal)

Important : La possibilité d'utiliser de cette fonction est maintenue pour compatibilité avec les versions précédentes de cette classe. Mais depuis la version 1.5, il est recommandé de ne plus l'utiliser et de renseigner le tableau de personnalisation/traduction directement comme cinquième paramètre lors de l'initialisation de la classe (c.f. paragraphe A/)




I/ ENVOI DU TELECHARGEMENT

L'emploi de la fonction "Upload" est bien entendu INDISPENSABLE et peut prendre un paramètre facultatif (constitué de tout caractère ou chaine de caractères non nulle) pour provoquer un rechargement de la page suite au téléchargement :

$var->Upload('reload');
ou
$var->Upload();


Note :

Le rechargement de la page permet d'éviter un multi post en cas de rafraichissement de la page de la part du visiteur. Evidemment, n'utilisez pas ce paramètre si vous avez un traitement PHP à faire à la suite du téléchargement ou si vous utiliser plusieurs fois la classe pour un même formulaire.




J/ RAFRAICHISSEMENT DE LA PAGE

A utiliser facultativement APRES la fonction "Upload", la fonction "Get_Reload_page" permet un rechargement de la page dans le cas de traitement php supplémentaire ou d'utilisation multiple de la classe pour un même formulaire (cf exemple formulaire 2 de mon second message). Cette fonction n'est utile que si l'on utilise la fonction "Upload" sans l'option "reload".

$var->Get_Reload_page();




K/ RECUPERATION DES MESSAGES D'INFORMATION

A utiliser facultativement APRES la fonction "Upload" : la fonction "Get_Tab_message" retourne le tableau des messages d'information. A noter que cette fonction ne peut être appelée qu'une fois, après quoi elle perd sa valeur.

$tab_messages = $var->Get_Tab_message;




L/ RECUPERATION DU TABLEAU DES RESULTATS

A utiliser facultativement APRES la fonction "Upload", la fonction "Get_Tab_upload" retourne le tableau des fichiers transférés en fonction des champs de téléchargement. Pratique par exemple pour enregistrer le résultat en base de données. A noter que cette fonction ne peut être appelée qu'une fois, après quoi elle perd sa valeur.

$tab_transfert = $var->Get_Tab_upload();






Notes :

- Les fonctions "Set_..." peuvent être appelées dans n'importe quel ordre mais AVANT la fonction "Upload" et les fonctions "Get_..." APRES la fonction "Upload"

- Pour limiter le poids maximum des fichiers en téléchargement avec vos propres valeurs, utilisez le champ de formulaire "<input type = "hidden" name = "MAX_FILE_SIZE"..." tel que donné en exemple dans mon second message. A noter que ce champ doit précéder les champs de type $_FILES.

- La valeur par défaut de qualité de redimensionnement des images (exprimée en pourcentage) est défini par la variable interne de la classe : private $qualite

- Les messages d'information et les résultats sont enregistrés dans une variable de session dont l'index est défini par la variable interne de la classe : private $index_ses

- Si vous ne faites pas afficher les messages d'information, les fichiers non valides ou présentant une erreur quelconque (dépassement de la taille maximum autorisée pour le téléchargement etc.) ne seront pas téléchargés mais vous n'en connaîtrez pas la cause.

<?php
// DEBUT DE CLASSE UPLOAD abciweb.net version 2.0
class Telechargement
{

private $index_ses = 'Verif-Up=Wxz';
private $reload_page = false;
private $extensions_autorisees = null;
private $ses_mes;
private $ses_vis;
private $ses_etat;
private $index_mes;
private $index_etat;
private $repertoire;
private $renomme = false;
private $mode_renommage_incr = false;
private $controle_fichier = false;
private $controle_img = false;
private $verif_ext;
private $file_form;
private $verif_post;
private $verif_get;
private $adresse_repertoire;
private $dim_image_source = null;
private $nouveau_nom = null;
private $nouveau_nom_ext = null;

private $redimension = array();
private $qualite = 88;

private $tab_mes = array(
'Le poids total maximum du formulaire autorisé par le serveur est dépassé',
'téléchargé dans le dossier',
'renommé',
'problème lors du transfert du fichier',
'extension non autorisée. Extensions autorisées :',
'non valide. Veuillez renommer votre fichier avant le téléchargement',
'ce fichier existe déjà',
'n\'est pas une image valide. Types de fichiers autorisés : gif, jpg, jpeg, png',
'excède la taille maximale de fichier autorisée par le serveur',
'excède la taille maximale de fichiers autorisée dans le formulaire',
'non téléchargé. Problème lors du téléchargement vers le serveur',
'a une résolution trop importante pour être traité. Envoyez un fichier avec une résolution inférieure',
'problème lors de la création de l\'image intermédiaire. Fichier non traité',
'problème lors du redimensionnement',
'problème lors du transfert du fichier redimensionné',
'redimensionné en',
'optimisé en',
'nom de destination du fichier non valide',
'téléchargement OK'
);




               
               
public function __construct ($repertoire = null, $verif_post = null, $file_form = null, $verif_get = null, $tab_message = null)
{      
	if (!session_id()) session_start();

		 
	$this->repertoire = trim($repertoire);
	$this->verif_post = trim($verif_post);
	$this->file_form = trim($file_form);
	$this->verif_get = trim($verif_get);
	
	$this->Verif_param();
	$this->Verif_repertoire($this->repertoire);
	
	$this->index_mes = $this->verif_post.' '.$this->file_form.'mes';                      
	$this->index_etat = $this->verif_post.' '.$this->file_form;

	$this->ses_mes[$this->index_mes] =& $_SESSION[$this->index_ses][$this->index_mes]; 
	$this->ses_etat[$this->index_etat] =& $_SESSION[$this->index_ses][$this->index_etat];
	
	if (isset($tab_message)) $this->Set_Tab_messages($tab_message);
	
	$this->Verif_max_post();
	
}






// FONCTIONS DE CONTROLE DES DONNEES WEBMESTRE
private function Verif_param ()
{
	try
		{
			if(empty($this->repertoire) || empty($this->verif_post) || empty($this->file_form))
												 
			throw new Exception('Les trois premiers paramètres de la classe de téléchargement de fichiers, correspondant :<br /><br />- 1/ Au nom du répertoire de destination  <br />- 2/ Au nom du champ $_POST de contrôle d\'envoi du formulaire  <br />- 3/ Au nom du champ $_FILES du formulaire<br /><br /> DOIVENT ETRE REMPLIS<br />');                                          
		}
											 
	catch(Exception $e)
			 
		{
			echo $e->getMessage ();
			exit;
		}      
}



			 
			 
			 
private function Verif_repertoire ($rep)
{                              
	try
		{                                                              
			if (!is_dir($this->Adresse_repertoire($rep)))
				{
					throw new Exception('- Chemin du dossier de destination "'.$this->Adresse_repertoire($rep).'" NON VALIDE');
				}
										 
			if (!is_writable($this->Adresse_repertoire($rep)))                  
				{
					throw new Exception('- Chemin du dossier de destination "'.$this->Adresse_repertoire($rep).'" NON ACCESSIBLE EN ECRITURE');
				}
																			 
		}
											 
	catch(Exception $e)
			 
		{
			echo $e->getMessage();
			exit;
		}
	 
}              






private function Verif_tab_extension ()
{            
	try
		{
			if(is_array($this->extensions_autorisees))                                                    
				{
					if(count($this->extensions_autorisees) > 0)  
																																				
						$this->verif_ext = true;
						else
						$this->verif_ext = false;
				}                  
				else if ($this->controle_img === false && count($this->redimension) == 0)
				{
					throw new Exception("Par sécurité, vous devez employer la fonction \"Set_Extensions_accepte\" pour envoyer un tableau d'extensions autorisées après l'initialisation de la classe et avant l'utilisation de la fonction d'upload, excepté si vous employez la fonction \"Set_Controle_dimImg\" qui contrôle des images de type gif, jpg, jpeg ou png, ou si vous employez la fonction \"Set_Redim\" de redimensionnement des images qui effectue ces mêmes contrôles.<br /><br />Alternativement, si vous ne souhaitez pas vérifier l'extension des fichiers, envoyez un tableau vide.");            
				}
		}
																											 
	catch(Exception $e)
											 
		{
			echo $e->getMessage();
			exit;
		}
}






private function Verif_tab_messages ($tab)
{                              
	try
		{                                                              
			if (!is_array($tab))
				{
					throw new Exception('- Le tableau des messages envoyé en paramètre n\'est pas un tableau valide. Il doit correspondre au tableau suivant : <br >');
				}
									 
			if (count($tab) != count($this->tab_mes))                  
				{
					throw new Exception('- Le tableau des messages envoyé en paramètre n\'a pas le nombre d\'éléments nécessaire (= '.count($this->tab_mes).') correspondant aux libellés suivants : <br >');
				}
																		 
		}
											 
	catch(Exception $e)
			 
		{
			echo $e->getMessage();
			echo '<pre>';
			print_r($this->tab_mes);
			echo '</pre>';
			exit;
		}
 
}              




		 

private function Verif_nouveau_nom ($nom, $param = null)
{                              
	try
		{                                                              
			$nom_fichier = $this->Nettoie_nom_fichier($nom);
			 
			if($nom_fichier === false)
				{
					throw new Exception('- Le nom de fichier "'.$nom.'" envoyé en paramètre à la fonction "Set_Nomme_fichier" n\'est pas un nom de fichier valide.');
				}      
					 
			if($nom_fichier !== $nom)
				{
					throw new Exception('- Le nom de fichier "'.$nom.'" envoyé en paramètre à la fonction "Set_Nomme_fichier" n\'est pas un nom de fichier valide. Suggestion possible : "'.$nom_fichier.'"');
				}                                                                                          
		}
											 
	catch(Exception $e)
			 
		{
			if (empty($param))
				{
					echo $e->getMessage();
					exit;
				}
				else
				{
					if (!empty($this->tab_mes[17])) $this->Set_message('', '', '"'.$nom.'" : '.$this->tab_mes[17]);
					$this->nouveau_nom = false;
				}
		}
 
}              






// FONCTIONS PUBLIQUES        
public function Set_Extensions_accepte ($extensions_autorisees)
{
	$this->extensions_autorisees = $extensions_autorisees;
}






public function Set_Renomme_fichier($incr = null)
{
	if (isset($incr) && trim($incr) != '') $this->mode_renommage_incr = true;
										 
	$this->renomme = true;
}






public function Set_Nomme_fichier($nom = null, $extension = null, $param = null)
{
	$nom = trim($nom);
	$param = trim($param);
	 
	$this->Verif_nouveau_nom($nom,$param);
										 
	$this->nouveau_nom = isset($this->nouveau_nom)? $this->nouveau_nom : $nom;
	 
	if(isset($extension) && trim($extension) != '') $this->nouveau_nom_ext = true;
}






public function Set_Controle_fichier()
{
	$this->controle_fichier = true;
}
			 

					 
			 

							 
public function Set_Controle_dimImg ()
{
	$this->controle_img = true;
}






public function Get_Tab_message ()
{
	if (isset($this->ses_mes[$this->index_mes]))
		{
			$tab_result = $this->ses_mes[$this->index_mes];
												 
			$this->ses_mes[$this->index_mes] = null;
												 
			return $tab_result;
		}
											 
		else return array();                          
}






public function Get_Tab_upload ()
{  
	if (isset($this->ses_etat[$this->index_etat]))
										 
		{
			$tab_result = array();
																																												 
			$infos_formulaire = explode(' ',$this->index_etat);
				 
			$tab_result['identifiant'] = $infos_formulaire[0];
												 
			$tab_result['champ'] = isset($infos_formulaire[1])? $infos_formulaire[1] : '';
												 
			$tab_result['resultat'] = array();
												 
															 
			foreach($this->ses_etat[$this->index_etat] as $num => $rep)
				{                                          
					foreach ($rep as $key => $value)      
						{
							$infos_fichier = explode(' ',$value);
																																
							$tab_result['resultat'][$num][$key]['nom'] = $infos_fichier[0];
							$tab_result['resultat'][$num][$key]['dim'] = isset($infos_fichier[1])? $infos_fichier[1] : '';        
						}
				}

			$this->ses_etat[$this->index_etat] = null;
												 
			return $tab_result;
		}
													 
		else return array();
}      






public function Get_Reload_page ()
{
	header("Location:".$_SERVER['PHP_SELF']);
	exit;  
}      






public function Return_Octets($val)
{
	$val = trim($val);
	$last = strtolower($val[strlen($val)-1]);

	switch($last)
			{
				case 'g':  $val *= 1024;
				case 'm': $val *= 1024;
				case 'k':  $val *= 1024;
			}

	return $val;
}






public function Set_Redim ($largeur_max = null, $hauteur_max = null, $rep_redim = null, $qualite = null, $limit_redim = null)
{
											 
	$rep_redim = !empty($rep_redim) && trim($rep_redim) != '' ? trim($rep_redim) : $this->repertoire;
				 
	if($rep_redim != $this->repertoire) $this->Verif_repertoire($rep_redim);
				 
				 
	$largeur_max =  isset($largeur_max) && trim($largeur_max) != '' ? trim($largeur_max) : null;
	$this->redimension[$rep_redim]['L_max'] = is_numeric($largeur_max) && !empty($largeur_max) ? abs(intval($largeur_max)) : null;
				 
	$hauteur_max = !empty($hauteur_max) && trim($hauteur_max) != '' ? trim($hauteur_max) : null;
	$this->redimension[$rep_redim]['H_max'] = is_numeric($hauteur_max) && !empty($hauteur_max) ? abs(intval($hauteur_max)) : null;
				 
	$qualite = !empty($qualite) && trim($qualite) != '' ? trim($qualite) : null;
	$this->redimension[$rep_redim]['Qualite'] = is_numeric($qualite) && intval($qualite) > 0 && intval($qualite) < 101 ? intval($qualite) : $this->qualite;
				 
	$this->redimension[$rep_redim]['Limit_redim'] = isset($limit_redim) && trim($limit_redim) != '' ? false : true;        
												 
}






public function Set_Tab_messages ($tab = null)
{
	$this->Verif_tab_messages($tab); 

	$this->tab_mes = array_map('trim',$tab);
}






public function Upload ($reload = null)
{
	if (!empty($reload)) $this->reload_page = true;
										 
	$this->Upload_Liste();
}

			 
			 
			 
			 
			 
// FONCTION UPLOAD : Liste (dans le cas d'un tableau) le champ spécifié de type $_FILES et envoie le résultat à la fonction Upload_fichier puis effectue ou non un reload
private function Upload_Liste ($reload = null)
{              
	$this->Verif_tab_extension();
	
																																																	
	if (isset($_POST[$this->verif_post],$_FILES[$this->file_form]))
		{                      
			$localfile = $_FILES[$this->file_form]['name'];
																											
			if (is_array($localfile))
				{      
					foreach ($localfile as $index_champ => $nom_fichier)
						{
							$nom_local = $_FILES[$this->file_form]['name'][$index_champ];
							$nom_temp = $_FILES[$this->file_form]['tmp_name'][$index_champ];
							$erreur = $_FILES[$this->file_form]['error'][$index_champ];	
							
							$this->Upload_fichier ($index_champ,$nom_local,$nom_temp,$erreur);
						}																												   
				 }                                
				 else                                      
				 {
					$nom_local = $_FILES[$this->file_form]['name'];
					$nom_temp = $_FILES[$this->file_form]['tmp_name'];
					$erreur = $_FILES[$this->file_form]['error'];
																															
					$this->Upload_fichier (0,$nom_local,$nom_temp,$erreur);
				}
																											 
			if ($this->reload_page === true) $this->Get_Reload_page();                                                                                             
		}            
}
			 
			 
			 


			 
// FONCTION UPLOAD FICHIER          
private function Upload_fichier ($index_champ, $nom_local, $nom_temp, $erreur)
{  
			 
	$adresse_fichier = $this->Verif_upload_fichier($index_champ, $nom_local, $nom_temp, $erreur);
				 
	if ($adresse_fichier === false) return false;
																 
	if ($this->renomme === true) $adresse_fichier = $this->Rename_fich($adresse_fichier);


	if (count($this->redimension) > 0)
		{
			$redim = $this->Redim_liste ($index_champ, $nom_local, $nom_temp, $adresse_fichier);
										 
			if($redim === false) return false;
			
			
			if (array_key_exists($this->repertoire,$this->redimension)) return false;
		}

										 
	if (@move_uploaded_file($nom_temp, $adresse_fichier))
		{
			$nom_fichier = basename($adresse_fichier);
																 
			$resultat1 = !empty($this->tab_mes[1]) ? '"'.$nom_local.'" '.$this->tab_mes[1].' "'.$this->repertoire.'"' : null;
			$resultat2 = !empty($this->tab_mes[1]) && !empty($this->tab_mes[2]) ? '"'.$nom_local.'" '.$this->tab_mes[2].' "'.$nom_fichier.'" '.$this->tab_mes[1].' "'.$this->repertoire.'"' : null;

			$resultat = $nom_local === $nom_fichier ?  $resultat1 : $resultat2;
			
			if (isset($resultat)) 
			$this->Set_message ($this->repertoire, $index_champ, $resultat);
			else
			$this->Set_message ($this->repertoire, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[18]);

			if (($this->controle_img === true || count($this->redimension) > 0) && isset($this->dim_image_source))
															 
				{
					$dim = implode('x',$this->dim_image_source);
																				 
					$this->Set_result ($this->repertoire, $index_champ, $nom_fichier.' '.$dim);
				}                                                                      
				else                                                  
					$this->Set_result ($this->repertoire, $index_champ, $nom_fichier);
																								 
		}                          
		else      
		{
			if (!empty($this->tab_mes[3])) $this->Set_message ($this->repertoire, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[3]);
			$this->Set_result ($this->repertoire, $index_champ, false);
																 
			@unlink($nom_temp);
		}                                                            

}






// FONCTION VERIF UPLOAD FICHIER
private function Verif_upload_fichier ($index_champ, $nom_local, $nom_temp, $erreur)
{  
	// Si $erreur != 0 problème lors de l'upload ou champ vide (=4)      
	if ($erreur !== 0)                    
		{
			if ($erreur != 4) 
				{
					if ($this->Files_erreur($erreur,$nom_local) != null) $this->Set_message ($this->repertoire, $index_champ, $this->Files_erreur($erreur,$nom_local));
				}
												 
			$this->Set_result ($this->repertoire, $index_champ, false);
			
			return false;
		}                  


	// Si le témoin de vérification "$this->verif_ext" sur les extensions retourne true
	if ($this->verif_ext === true)                                                  
		{
			 if ($this->Verif_extension($nom_local) === false)
				{
					$liste_extensions = implode(', ',$this->extensions_autorisees);
														 
					if (!empty($this->tab_mes[4])) $this->Set_message ($this->repertoire, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[4].' '.$liste_extensions);
					
					$this->Set_result ($this->repertoire, $index_champ, false);
					
					return false;                                      
				 }      
		}


	//Si nouveau_nom et nouveau_nom_ext définis -> nouveau_nom prend l'extension du fichier téléchargé
	if (isset($this->nouveau_nom) && $this->nouveau_nom !== false)
		{
			$nom_fichier = isset($this->nouveau_nom_ext)? $this->nouveau_nom.'.'. strtolower(substr($nom_local,strrpos($nom_local, ".")+1)) : $this->nouveau_nom;
		}        
																																														 
	// Nettoyage du nom de fichier pour avoir un nom de fichier valide sur le serveur
	if(!isset($this->nouveau_nom)) $nom_fichier = $this->Nettoie_nom_fichier($nom_local);
		 
	if ($nom_fichier === false || $this->nouveau_nom === false)
		{
			if (isset($this->nouveau_nom))
			 
				return false;
				 
				else
					{
						if (!empty($this->tab_mes[5])) $this->Set_message ($this->repertoire, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[5]);
															 
						$this->Set_result ($this->repertoire, $index_champ, false);

						return false;
					}
		 }
																																													 

	// Si l'on a employé la fonction "Set_Controle_fichier"                                
	if ($this->controle_fichier === true)
		{
			if (is_file($this->Adresse_repertoire($this->repertoire).$nom_fichier))
				{
					$nom = isset($this->nouveau_nom)? $this->nouveau_nom : $nom_local;
					 
					if (!empty($this->tab_mes[6])) $this->Set_message ($this->repertoire, $index_champ, '"'.$nom.'" '.$this->tab_mes[6]);
														 
					$this->Set_result ($this->repertoire, $index_champ, false);
					
					return false;
				}                      
		}
																		 
																		 
	// Si l'on a employé la fonction "Set_Controle_dimImg"
	if ($this->controle_img === true && count($this->redimension) == 0)
		{
			$this->dim_image_source = null;
												 
			$infos_images = $this->Infos_image($nom_temp);
												 
			if ($infos_images === false)
				{                                                      
					if (!empty($this->tab_mes[7])) $this->Set_message ($this->repertoire, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[7]);
					$this->Set_result ($this->repertoire, $index_champ, false);
																																																																
					return false;
				}
				else
				{
					$this->dim_image_source = array_slice($infos_images, 0, 2);
				}
		}
																																																										 
	// Si on arrive ici c'est que tout c'est bien passé et l'on retourne l'adresse de destination du fichier
	return $this->Adresse_repertoire($this->repertoire).$nom_fichier;																															
}





			 
private function Set_message ($repertoire = null, $index = null, $message)
{
	if (isset($index))
										 
	$this->ses_mes[$this->index_mes][$index][$repertoire] = $message;
										 
	else
										 
	$this->ses_mes[$this->index_mes][] = $message;
}






private function Set_result ($repertoire = null, $index, $message)
{              
	$this->ses_etat[$this->index_etat][$index][$repertoire] = $message;
}






private function Verif_extension ($fichier)
{
	$extension = strtolower(substr($fichier,strrpos($fichier, ".")+1));
						 
	if (in_array($extension,$this->extensions_autorisees))
						 
	return true;
	else
	return false;                  
}






private function Verif_max_post()
{                                                  
	if (isset($_GET[$this->verif_get]) && empty($_POST[$this->verif_post]))
		{
			if (!empty($this->tab_mes[0])) $this->Set_message ('', '', $this->tab_mes[0]);
			
			$this->Get_Reload_page ();                      
		}
}
			 
			 
			 
			 
											 
											 
private function Adresse_racine()
{
	$adresse_racine = (substr($_SERVER['DOCUMENT_ROOT'],-1) == '/')? $_SERVER['DOCUMENT_ROOT'] : $_SERVER['DOCUMENT_ROOT'].'/' ;
										 
	return $adresse_racine;
}              





											 
private function Adresse_repertoire($rep)
{
	return $this->Adresse_racine().$rep.'/';
}
			 
			 
			 
			 
			 
			 
private function Nettoie_nom_fichier($nom_fichier)
{
	$cible = array(
	'À', 'Á', 'Â', 'Ã', 'Ä', 'Å', 'Æ', 'Ă', 'Ą',
	'Ç', 'Ć', 'Č', 'Œ',
	'Ď', 'Đ',
	'à', 'á', 'â', 'ã', 'ä', 'å', 'æ', 'ă', 'ą',
	'ç', 'ć', 'č', 'œ',
	'ď', 'đ',
	'È', 'É', 'Ê', 'Ë', 'Ę', 'Ě',
	'Ğ',
	'Ì', 'Í', 'Î', 'Ï', 'İ',
	'Ĺ', 'Ľ', 'Ł',
	'è', 'é', 'ê', 'ë', 'ę', 'ě',
	'ğ',
	'ì', 'í', 'î', 'ï', 'ı',
	'ĺ', 'ľ', 'ł',
	'Ñ', 'Ń', 'Ň',
	'Ò', 'Ó', 'Ô', 'Õ', 'Ö', 'Ø', 'Ő',
	'Ŕ', 'Ř',
	'Ś', 'Ş', 'Š',
	'ñ', 'ń', 'ň',
	'ò', 'ó', 'ô', 'ö', 'ø', 'ő',
	'ŕ', 'ř',
	'ś', 'ş', 'š',
	'Ţ', 'Ť',
	'Ù', 'Ú', 'Û', 'Ų', 'Ü', 'Ů', 'Ű',
	'Ý', 'ß',
	'Ź', 'Ż', 'Ž',
	'ţ', 'ť',
	'ù', 'ú', 'û', 'ų', 'ü', 'ů', 'ű',
	'ý', 'ÿ',
	'ź', 'ż', 'ž',
	'А', 'Б', 'В', 'Г', 'Д', 'Е', 'Ё', 'Ж', 'З', 'И', 'Й', 'К', 'Л', 'М', 'Н', 'О', 'П', 'Р',
	'а', 'б', 'в', 'г', 'д', 'е', 'ё', 'ж', 'з', 'и', 'й', 'к', 'л', 'м', 'н', 'о', 'р',
	'С', 'Т', 'У', 'Ф', 'Х', 'Ц', 'Ч', 'Ш', 'Щ', 'Ъ', 'Ы', 'Ь', 'Э', 'Ю', 'Я',
	'с', 'т', 'у', 'ф', 'х', 'ц', 'ч', 'ш', 'щ', 'ъ', 'ы', 'ь', 'э', 'ю', 'я'
	);
				 
	$rempl = array(
	'A', 'A', 'A', 'A', 'A', 'A', 'AE', 'A', 'A',
	'C', 'C', 'C', 'CE',
	'D', 'D',
	'a', 'a', 'a', 'a', 'a', 'a', 'ae', 'a', 'a',
	'c', 'c', 'c', 'ce',
	'd', 'd',
	'E', 'E', 'E', 'E', 'E', 'E',
	'G',
	'I', 'I', 'I', 'I', 'I',
	'L', 'L', 'L',
	'e', 'e', 'e', 'e', 'e', 'e',
	'g',
	'i', 'i', 'i', 'i', 'i',
	'l', 'l', 'l',
	'N', 'N', 'N',
	'O', 'O', 'O', 'O', 'O', 'O', 'O',
	'R', 'R',
	'S', 'S', 'S',
	'n', 'n', 'n',
	'o', 'o', 'o', 'o', 'o', 'o',
	'r', 'r',
	's', 's', 's',
	'T', 'T',
	'U', 'U', 'U', 'U', 'U', 'U', 'U',
	'Y', 'Y',
	'Z', 'Z', 'Z',
	't', 't',
	'u', 'u', 'u', 'u', 'u', 'u', 'u',
	'y', 'y',
	'z', 'z', 'z',
	'A', 'B', 'B', 'r', 'A', 'E', 'E', 'X', '3', 'N', 'N', 'K', 'N', 'M', 'H', 'O', 'N', 'P',
	'a', 'b', 'b', 'r', 'a', 'e', 'e', 'x', '3', 'n', 'n', 'k', 'n', 'm', 'h', 'o', 'p',
	'C', 'T', 'Y', 'O', 'X', 'U', 'u', 'W', 'W', 'b', 'b', 'b', 'E', 'O', 'R',
	'c', 't', 'y', 'o', 'x', 'u', 'u', 'w', 'w', 'b', 'b', 'b', 'e', 'o', 'r'
	);
		 
	$nom_fichier = str_replace($cible, $rempl, $nom_fichier);

	$nom_fichier = preg_replace('#[^.a-z0-9_-]+#i', '', $nom_fichier);
						 
	if (trim($nom_fichier) != '')
						 
	return $nom_fichier;
	else
	return false;
}
			 





private function Rename_fich($adresse_fichier)
{
	if (is_file($adresse_fichier))
		{
			$info = pathinfo($adresse_fichier);
			$extension = isset($info['extension'])? '.'.$info['extension'] : null;
			$dossier = $info['dirname'];
			$basename = $info['basename'];

			$filename = isset($extension) && strrpos($basename,$extension) !== false ? substr($basename,0,strrpos($basename,$extension)) : $basename;
			
			if ($this->mode_renommage_incr === true)
				{
					$file = $filename.'_'; 
					$file = addcslashes($file,'.');
					
					$ext = isset($extension) ? addcslashes($extension,'.') : null;
										
					$match = isset($extension)? '#'.$file.'[0-9]+'.$ext.'#' : '#'.$file.'[0-9]+$#';
					
					$tab_identique = array();
					
					if(class_exists('RegexIterator'))
						{
							$files = new RegexIterator(new DirectoryIterator($dossier),$match);
							foreach ($files as $fileinfo) $tab_identique[] = $fileinfo->getFilename();
						}	
						else
						{	
							$files = new DirectoryIterator($dossier);			
							foreach ($files as $fileinfo) if (preg_match($match,$fileinfo->getFilename())) $tab_identique[] = $fileinfo->getFilename();	
						}
					
					natsort($tab_identique);
					
					$dernier = array_pop($tab_identique);
					
					unset($tab_identique);
								
					
					$dernier = isset($dernier)? basename($dernier,$extension) : '';																																			
					
					$file = preg_replace_callback('#([0-9]+$)#', create_function('$matches','return $matches[1]+1;'), $dernier, '1', $count);
									 
					$filename = !empty($count)? $file : $filename.'_1';
					
				}
				else
				{
					$filename .= '_'.uniqid();
				}
																														 
			$filename = !empty($extension) ? $filename.$extension : $filename;
															 
																					 
			$adresse = $dossier.'/'.$filename;
			
			if (!is_file($adresse)) return $adresse;
			else																													
			return $this->Rename_fich($adresse_fichier);                        
	}
																					 
	else 
	{
		return $adresse_fichier;
	}
}





			 
private function Files_erreur ($file_error, $nom_fichier)
{
	$message = null;
						 
	switch ($file_error)
		{
			case "1" : $message = !empty($this->tab_mes[8]) ? '"'.$nom_fichier.'" '.$this->tab_mes[8] : null; break;
			case "2" : $message = !empty($this->tab_mes[9]) ? '"'.$nom_fichier.'" '.$this->tab_mes[9] : null; break;
			case "3" :
			case "4" :
			case "6" :
			case "7" :
			case "8" : $message = !empty($this->tab_mes[10]) ? '"'.$nom_fichier.'" '.$this->tab_mes[10] : null; break;
		}          

	return $message;
}






private function Enoughmem ($x, $y, $max_mem, $rgb = 3) 
{	
	if (function_exists('memory_get_usage')) 
		{
			//http://www.php.net/manual/fr/function.imagecreatetruecolor.php#99623
			return ( $x * $y * $rgb * 1.7 < $max_mem - memory_get_usage() );
		}
	else return true;
}






private function Infos_image ($fich)
{
	$types_accepte = array(1,2,3);
	 
	$infos = @getimagesize($fich);     
				 
	if (!empty($infos[0]) && !empty($infos[1]) && !empty($infos[2]) && in_array($infos[2],$types_accepte))
				 
	return array($infos[0], $infos[1], $infos[2], $infos['bits'], $infos['channels']);                 
	else       
	return false;
}



			 
			 

private function Redim_liste ($index_champ, $nom_local, $nom_temp, $adresse_fichier)
{                              
							 
	$info_image = $this->Infos_image ($nom_temp);
	 
	$this->dim_image_source = null;

	 
	if ($info_image === false)            
	{
		if (!empty($this->tab_mes[7])) $this->Set_message ($this->repertoire, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[7]);
		$this->Set_result ($this->repertoire, $index_champ, false);
																																				
		return false;
	}
	else
	{
		$this->dim_image_source = array_slice($info_image, 0, 2);
	}      
 
 
	$dim_max = true;
 
	if ($info_image[2] == 2)               
	{                      
		$m_limit = ini_get('memory_limit');
		$m_limit = $this->Return_Octets($m_limit);

		if (!$this->Enoughmem($info_image[0],$info_image[1],$m_limit))
			{
				$dim_max = false;                                      
			}
	}
								 
																				 
	$nouvelle_image = $dim_max === true ? $this->Image_create ($nom_temp, $info_image[2]) : false;


	$nom_fichier = basename($adresse_fichier);


	foreach ($this->redimension as $rep => $value)
	{
	 
		if($dim_max === false)
			{
				if (!empty($this->tab_mes[11])) $this->Set_message ($rep, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[11]);
				$this->Set_result ($rep, $index_champ, false);
				
				break;
			}
 
 
		if ($nouvelle_image === false && $dim_max === true)
			{
				if (!empty($this->tab_mes[12])) $this->Set_message ($rep, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[12]);
													 
				$this->Set_result ($rep, $index_champ, false);
				 
				break;
			}
		 
																 
		$largeur_max = $value['L_max'];
		$hauteur_max = $value['H_max'];
		$qualite = $value['Qualite'];
		$limit_redim = $value['Limit_redim'];                          
					 
		$redimensionnement = true;
					 
		if(empty ($largeur_max) && empty ($hauteur_max))
			{
				$largeur_destination = $info_image[0];
				$hauteur_destination = $info_image[1];
				$redimensionnement = false;
			}
			else          
			{
				$ratio_orig = $info_image[0]/$info_image[1];
							 
				if(!empty ($largeur_max) && empty ($hauteur_max))
					{                      
						$largeur_destination = intval ($largeur_max);
						$hauteur_destination = intval ($largeur_max/$ratio_orig);
					}
					else if (empty ($largeur_max) && !empty ($hauteur_max))
					{      
						$largeur_destination = intval ($hauteur_max*$ratio_orig);
						$hauteur_destination = intval ($hauteur_max);
					}
					else
					{
						$ratioh = $hauteur_max/$info_image[1];
						$ratiow = $largeur_max/$info_image[0];
						$ratio = min($ratioh, $ratiow);
	 
						$largeur_destination = intval ($ratio*$info_image[0]);
						$hauteur_destination  = intval ($ratio*$info_image[1]);        
					}
				 
								 
			if(($largeur_destination > $info_image[0] || $hauteur_destination > $info_image[1]) && $limit_redim === true)
					{
						$largeur_destination = $info_image[0];
						$hauteur_destination = $info_image[1];
						$redimensionnement = false;
					}      
			}


		if ($redimensionnement && $nouvelle_image !== false)
			{    
				$dim_desti = true;
				 
				if ($info_image[2] == 2)               
					{
						if (!$this->Enoughmem($largeur_destination,$hauteur_destination,$m_limit))
						$dim_desti = false;
					}

																						 
				$ressource = $dim_desti == true ? @imagecreatetruecolor ($largeur_destination, $hauteur_destination) : false;
							 
				if (!is_resource ($ressource))
					{
						if (!empty($this->tab_mes[11])) $this->Set_message ($rep, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[11]);
															 
						$this->Set_result ($rep, $index_champ, false);

						break;
					}
							 

				$redimensionnement = @imagecopyresampled ($ressource, $nouvelle_image, 0, 0, 0, 0, $largeur_destination, $hauteur_destination, $info_image[0], $info_image[1]);
							 
				if ($redimensionnement == false)
					{
						if (!empty($this->tab_mes[13])) $this->Set_message ($rep, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[13]);
															 
						$this->Set_result ($rep, $index_champ, false);

						break;
					}
											 
											 
				$envoi = $this->Envoi_image ($ressource, $this->Adresse_repertoire($rep).$nom_fichier, $info_image[2], $qualite);
							 
							 
				@imagedestroy($ressource);
							 
							 
				if ($envoi === false)
					{
						if (!empty($this->tab_mes[14])) $this->Set_message ($rep, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[14]);
															 
						$this->Set_result ($rep, $index_champ, false);

						break;
					}
								 
					else
								 
					{						
						$resultat1 = !empty($this->tab_mes[15]) && !empty($this->tab_mes[1]) ? '"'.$nom_fichier.'" '.$this->tab_mes[15].' '.$largeur_destination.'x'.$hauteur_destination.' '.$this->tab_mes[1].' '.$rep.'' : null;
						
						$resultat2 = !empty($this->tab_mes[15]) && !empty($this->tab_mes[1]) && !empty($this->tab_mes[2]) ? '"'.$nom_local.'" '.$this->tab_mes[2].' "'.$nom_fichier.'" '.$this->tab_mes[15].' '.$largeur_destination.'x'.$hauteur_destination.' '.$this->tab_mes[1].' '.$rep.'' : null;

						$resultat = $nom_local === $nom_fichier ?  $resultat1 : $resultat2;
		
						if (isset($resultat)) 
						$this->Set_message ($rep, $index_champ, $resultat);
						else
						$this->Set_message ($rep, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[18]);

									 
						$dim = $largeur_destination.'x'.$hauteur_destination;
																	 
						$this->Set_result ($rep, $index_champ, $nom_fichier.' '.$dim);
					}
														 
			}

			else if ($nouvelle_image !== false)
					 
			{

				$envoi = $this->Envoi_image ($nouvelle_image, $this->Adresse_repertoire($rep).$nom_fichier, $info_image[2], $qualite);
							 
				if ($envoi === false)
					{
						if (!empty($this->tab_mes[3])) $this->Set_message ($rep, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[3]);
															 
						$this->Set_result ($rep, $index_champ, false);
																													 
						break;
					}
					else
					{
						$resultat1 = !empty($this->tab_mes[16]) && !empty($this->tab_mes[1]) ? '"'.$nom_fichier.'" '.$this->tab_mes[16].' '.$largeur_destination.'x'.$hauteur_destination.' '.$this->tab_mes[1].' '.$rep.'' : null;
						
						$resultat2 = !empty($this->tab_mes[16]) && !empty($this->tab_mes[1]) && !empty($this->tab_mes[2]) ? '"'.$nom_local.'" '.$this->tab_mes[2].' "'.$nom_fichier.'" '.$this->tab_mes[16].' '.$largeur_destination.'x'.$hauteur_destination.' '.$this->tab_mes[1].' '.$rep.'' : null;

						$resultat = $nom_local === $nom_fichier ?  $resultat1 : $resultat2;
		
						if (isset($resultat)) 
						$this->Set_message ($rep, $index_champ, $resultat);
						else
						$this->Set_message ($rep, $index_champ, '"'.$nom_local.'" '.$this->tab_mes[18]);
						
									 
						$dim = $largeur_destination.'x'.$hauteur_destination;
																	 
						$this->Set_result ($rep, $index_champ, $nom_fichier.' '.$dim);
					}
							 
			}
																 
	}
				 
	@imagedestroy($nouvelle_image);
}

																								 




private function Image_create($fich, $type)
{
	switch ($type)
		{
			case "1" : $nouvelle_image = @imagecreatefromgif($fich); break;
			case "2" : $nouvelle_image = @imagecreatefromjpeg($fich); break;
			case "3" : $nouvelle_image = @imagecreatefrompng($fich); break;
						 
			default : $nouvelle_image = null;
		}
					 
	if (is_resource($nouvelle_image))
 
	return $nouvelle_image;
	else
	return false;
}
			 
			 
			 
			 

			 
private function Envoi_image($ressource, $destination, $type, $qualite)
{              
	switch ($type)
		{
			case "1" : $envoi = @imagegif($ressource, $destination); break;
			case "2" : $envoi = @imagejpeg($ressource, $destination, $qualite); break;
			case "3" : $qualite = $qualite == 0 ? 1 : $qualite;
					$qualite = 10 - ceil($qualite/10);                          
					$envoi = @imagepng($ressource, $destination, $qualite); break;
						 
			default : $envoi = false;
		}
								 
	if ($envoi != false)
				 
	return true;  
	else
	return false;
}

}
//FIN DE CLASSE
?>

<?php
require('Classe_upload.php');

/*EXEMPLE
Paramétrage en fonction des deux formulaires de téléchargement intégrés dans le code source.
Pour un fonctionnement sans modification des paramètres, suppose les répertoires PHOTO, PHOTO_GF, PHOTO_PF  et PDF situés à la racine du site.*/



// FORMULAIRE 1

// Téléchargement de photos avec contrôle anti-écrasement d'un fichier déjà existant, et contrôle des images

// Déclaration de la classe avec envoi des paramètres
$form_1 = new Telechargement ('PHOTO','formulaire_1','photo','get_formulaire_1');


// Contrôle simple (anti écrasement) de l'existence d'un fichier de nom identique dans le répertoire de destination
$form_1->Set_Controle_fichier ();

// Contrôle que le fichier est effectivement une image de type gif, jpg, jpeg ou png et retourne ses dimensions dans le tableau des résultats
$form_1->Set_Controle_dimImg ();


//Téléchargement sans traitement php supplémentaire -> on spécifie un rechargement de la page suite au téléchargement en indiquant un argument non nul ex 'reload' dans la fonction d'Upload.
$form_1->Upload('reload');


// Enregistrement des messages de contrôle (si besoin)
$messages_form1 = $form_1->Get_Tab_message ();

// Enregistrement du tableau des résultats (si besoin)
$tranfert_form1 = $form_1->Get_Tab_upload ();




// FORMULAIRE 2

// Téléchargements de fichiers de nature différentes (photos et pdf) dans des répertoires différents avec si besoin renommage des fichiers, puis redimentionnement des images et traitement php.

$form2_photo = new Telechargement('PHOTO','formulaire_2','photo','get_formulaire_2');


// Tableau des extensions autorisées (en minuscules). Dans cet exemple, seules les extensions "jpg" et "jpeg" sont autorisées
$tab_extensions_autorisees = array('jpg','jpeg');
// Envoi du tableau des extensions autorisées
$form2_photo->Set_Extensions_accepte($tab_extensions_autorisees);

// Images originales téléchargées dans le répertoire "PHOTO" + mêmes images redimensionnées en max 950 x 800 téléchargées dans le répertoire "PHOTO_GF" + mêmes images redimensionnées en max 200 x 200 téléchargées dans le répertoire "PHOTO_PF"

$form2_photo->Set_Redim ('950','800','PHOTO_GF');
$form2_photo->Set_Redim ('200','200','PHOTO_PF');

// Contrôle de l'existence d'un fichier de nom identique dans le répertoire de destination et si oui renommage  du fichier téléchargé avec un suffixe aléatoire unique.
$form2_photo->Set_Renomme_fichier ();


// Téléchargement sans reload de la page
$form2_photo->Upload ();




// Dans le même formulaire un fichier pdf à télécharger dans le répertoire "PDF"
$form2_pdf = new Telechargement('PDF','formulaire_2','pdf','get_formulaire_2');        


// Tableau des extensions autorisées (en minuscules). Dans cet exemple, seules les extensions "pdf" sont autorisées
$extensions_pdf = array('pdf');
// Envoi du tableau des extensions autorisées
$form2_pdf->Set_Extensions_accepte ($extensions_pdf);

// Contrôle de l'existence d'un fichier de nom identique dans le répertoire de destination et si oui renommage du fichier téléchargé avec un suffixe incrémentiel
$form2_pdf->Set_Renomme_fichier ('incr');


// Téléchargement sans reload de la page
$form2_pdf->Upload ();



// Le reload de la page sera effectué à la fin du traitement php en utilisant la fonction "Get_Reload_page()"
if (isset($_POST['formulaire_2']))
        {

                //Récupération des résultats
                //$transfert_form2_photo = $form2_photo->Get_Tab_upload ();
                //$transfert_form2_pdf = $form2_pdf->Get_Tab_upload ();
                
                // Voir la structure du tableau de résultat, et un exemple de récupération en fin de script
                
                
                //enregistrement des données en bdd etc.
               
                // Rechargement de la page pour éviter un multiple post en cas de rafraichissement de la page par le visiteur
                $form2_photo->Get_Reload_page();
        }


// A noter que l'appel à la fonction Get_Tab_message() doit se faire APRES la condition "if (isset($_POST..."
$messages_form2_pdf = $form2_pdf->Get_Tab_message ();
$messages_form2_photo = $form2_photo->Get_Tab_message ();


// Les deux lignes ci-dessous doivent logiquement se trouver à l'intérieur la condition "if (isset($_POST...)" pour servir par exemple à alimenter une bdd. Elles sont ici uniquement pour démonstration et afficher la structure du taleau de résultat en bas de page.
$transfert_form2_photo = $form2_photo->Get_Tab_upload ();
$transfert_form2_pdf = $form2_pdf->Get_Tab_upload ();


// Vous pouvez éventuellement mettre la déclaration de la classe (et l'appel de ses fonctions) à l'intérieur de la condition "if (isset($_POST...)", cependant vous devrez alors enregistrer le tableau des messages dans une variable de session pour pouvoir y accéder après le reload de la page, et d'autre part le message indiquant un dépassement du $_POST maximum total autorisé par le serveur ne sera plus fonctionnel.




/* Debug

- Si aucun message ne s'affiche après l'envoi d'un fichier, un ou plusieurs paramètres passés dans la déclaration de la classe sont erronés ou les variables de session ne fonctionnent pas sur votre serveur.

- Si le message "Le total maximum du post autorisé par le serveur est dépassé" s'affiche même pour un fichier de petite taille, le nom de l'input d'identification du formulaire passé en deuxième paramètre lors de l'initialisation de la classe est erroné.

*/


?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Document sans titre</title>
<script type="text/javascript">
<!--
function Verif_attente(id_attente)
    {              
        var id_attente = document.getElementById(id_attente);
       
        if (typeof id_attente != 'undefined')
        {
            // Nettoyage de l'élément cible
            var nb_noeuds = id_attente.childNodes.length;
                       
            for (var i = 0; i < nb_noeuds; i++)        
                                {                                  
                                        id_attente.removeChild(id_attente.firstChild);
                                }
            
            id_attente.style.fontWeight="bold";
            id_attente.style.fontSize="1.5em";
            
            var texte = 'Patientez...';
            // Création du noeud texte
            var noeud_texte = document.createTextNode(texte);
            // Insertion du noeud texte
            id_attente.appendChild(noeud_texte);
        }
    }
-->
</script>
<style type="text/css">
body {
font-family: Arial, Helvetica, sans-serif;
font-size:12px;
}

p, input, form {
margin:0;
padding:0;
}
</style>
</head>

<body>

<div style="width:650px;margin:auto;margin-top:50px;">  

        <p>Fichiers photos (png, jpg, jpeg, gif)</p>
               
        <form enctype = "multipart/form-data" action = "<?php echo htmlspecialchars($_SERVER['PHP_SELF']).'?get_formulaire_1=1'?>" method = "post" onsubmit = "Verif_attente('message_tele')" id = "formulaire_1">
       
                <p>      
                        <!-- input d'identification du formulaire qui doit être passé en paramètre dans l'initialisation de la classe-->
                        <input type = "hidden" name = "formulaire_1" value = "1" />
                                                 
                        <!-- Par défaut MAX_FILE_SIZE = Return_Octets(ini_get('upload_max_filesize') donc ne sert à rien en l'état. Pour limiter l'upload à une taille inférieure vous pouvez rentrez une valeur suivie de son unité, exemple $form_1->Return_Octets('500K') pour 500 kilos octets, $form_1->Return_Octets('1M') pour 1 méga octets etc. La fonction "Return_Octets" est employée pour la conversion en octets car le champ MAX_FILE_SIZE demande une valeur en octets. -->
       
                        <input type = "hidden" name = "MAX_FILE_SIZE"  value = "<?php echo isset($form_1)? $form_1->Return_Octets(ini_get('upload_max_filesize')) : ''?>" />
                                   
                        <input name = "photo[]" type = "file" size = "70" /><br />
                                   
                        <input name = "photo[]" type = "file" size = "70" />
                                   
                        <input name = "photo[]" type = "file" size = "70" />
                                         
                        <input type = "submit" value = "Envoyez"  style = "margin-left:5px" />
                </p>
               
    </form>
               
        <p>
        <br />Taille maximum de fichier autorisée par le serveur = <?php echo ini_get('upload_max_filesize').'o'?>.&nbsp;&nbsp;Total maximum pour l'ensemble <?php echo ini_get('post_max_size').'o'?>.
        </p>

    <div id = "message_tele" style="margin-top:20px;">
               
                <?php if (!empty($messages_form1))
           
                foreach ($messages_form1 as $num)
                        {
                                foreach ($num as $value)
                                echo htmlspecialchars($value).'<br />';
                        }
                ?>
    </div>

</div>



<div style="width:650px;margin:auto;margin-top:80px;">
                       
        <form enctype = "multipart/form-data" action = "<?php echo htmlspecialchars($_SERVER['PHP_SELF']).'?get_formulaire_2=1'?>" method = "post" onsubmit = "Verif_attente('message_tele2')" id = "formulaire_2">
        <p>
               
                <!-- input d'identification du formulaire qui doit être passé en paramètre dans l'initialisation de la classe-->
                <input type = "hidden" name = "formulaire_2" value = "1" />
               
            <!-- Par défaut MAX_FILE_SIZE = Return_Octets(ini_get('upload_max_filesize') donc ne sert à rien en l'état. Pour limiter l'upload à une taille inférieure vous pouvez rentrez une valeur suivie de son unité, exemple $form2_pdf->Return_Octets('500K') pour 500 kilos octets, $form2_pdf->Return_Octets('1M') pour 1 méga octets etc. La fonction "Return_Octets" est employée pour la conversion en octets car le champ MAX_FILE_SIZE demande une valeur en octets. -->

                <input type = "hidden" name = "MAX_FILE_SIZE"  value = "<?php echo isset($form2_pdf) ? $form2_pdf->Return_Octets(ini_get('upload_max_filesize')) : '' ?>" />  
                       
            <label for="login">Login</label><br />
            <input type = "text" id = "login" name = "login"  size = "70" /><br />
               
            <span>Fichiers photos (png, jpg, jpeg, gif)</span><br />
                <input name = "photo[]" type = "file" size = "70" /><br />
                <input name = "photo[]" type = "file" size = "70" /><br />
       
            <label for="pdf">Fichier pdf (pdf)</label><br />
                <input id = "pdf" name = "pdf" type = "file" size = "70" />
               
                <input type = "submit" value = "Envoyez"  style = "margin-left:5px" />
               
        </p>
        </form>
                   
    <p>    
                <br />Taille maximum de fichier autorisée par le serveur = <?php echo ini_get('upload_max_filesize').'o'?>.&nbsp;&nbsp;Total maximum pour l'ensemble <?php echo ini_get('post_max_size').'o'?>.
        </p>
               
        <div id = "message_tele2" style="margin-top:20px;">
        <?php
        if (!empty($messages_form2_photo))
                        {
                                echo '<p>';
                                        foreach ($messages_form2_photo as $num)
                                                {
                                                        foreach ($num as $value)
                                                        echo htmlspecialchars($value).'<br />';
                                                }
                                echo '</p>';
                        }
                                                   
        if (!empty($messages_form2_pdf))
                        {
                                echo '<p>';
                                        foreach ($messages_form2_pdf as $num)
                                                {
                                                        foreach ($num as $value)
                                                        echo htmlspecialchars($value).'<br />';
                                                }
                                echo '</p>';
                        }
        ?>
        </div>
</div>  


<div style="margin-top:100px" >
        <p>
                <?php
                // Lecture du tableau des résultats (se trouve ici uniquement pour la démonstration et visualiser la structue des tableaux de résultat)
                if (!empty ($tranfert_form1))
                        {
                                $identifant = $tranfert_form1['identifiant'];
                                $champ = $tranfert_form1['champ'];    
                                $resultat = $tranfert_form1['resultat'];//tableau à trois dimensions
                           
                               
                                echo $identifant.' :<br /><br />';
                           
                                foreach ($resultat as $num => $rep)
                                        {
                                                foreach ($rep as $key => $value)
                                                        {                                                      
                                                                if(!empty($value['nom']))                                  
                                                                echo 'champ '.$champ.' n° '.$num.' = '.$value['nom'].' '. $value['dim'].', téléchargé dans "'.$key.'"<br />';
                                                        }    
                                        }  
                        } ?>
                <br />
        </p>
</div>


   
<div style="margin-top:100px">
        <p>
                <?php
                // Lecture du tableau des résultats (se trouve ici uniquement pour la démonstration et visualiser la structue des tableaux de résultat)
                if (!empty ($transfert_form2_photo))
                        {
                                $identifant = $transfert_form2_photo['identifiant'];
                                $champ = $transfert_form2_photo['champ'];      
                                $resultat = $transfert_form2_photo['resultat'];//tableau à trois dimensions  
                                                                   
                                echo $identifant.' :<br /><br />';
                           
                                foreach ($resultat as $num => $rep)
                                        {
                                                foreach ($rep as $key => $value)
                                                        {                                                      
                                                                if(!empty($value['nom']))                                  
                                                                echo 'champ '.$champ.' n° '.$num.' = '.$value['nom'].' '. $value['dim'].', téléchargé dans "'.$key.'"<br />';
                                                        }    
                                        }
                        } ?>
                <br />
        </p>

        <p>
                <?php
                // Lecture du tableau des résultats (se trouve ici uniquement pour la démonstration et visualiser la structue des tableaux de résultat)
                if (!empty ($transfert_form2_pdf))
                        {
                                $identifant = $transfert_form2_pdf['identifiant'];
                                $champ = $transfert_form2_pdf['champ'];        
                                $resultat = $transfert_form2_pdf['resultat'];//tableau à trois dimensions  
                               
   
                                foreach ($resultat as $num => $rep)
                                        {
                                                foreach ($rep as $key => $value)
                                                        {                                                          
                                                                if(!empty($value['nom']))                                  
                                                                echo 'champ '.$champ.' n° '.$num.' = '.$value['nom'].' '. $value['dim'].', téléchargé dans "'.$key.'"<br />';
                                                        }    
                                        }
                        } ?>
        </p>
</div>

</body>
</html>

Bonjour, j'ai beau chercher je ne trouve pas, il y a possibilité de changer le nom du fichier a uploader ?

private $qualite = 88;

private $nouveau_nom=null;

public function __construct ($repertoire = null, $verif_post = null, $file_form = null, $verif_get = null)

public function __construct ($repertoire = null, $verif_post = null, $file_form = null, $verif_get = null,$nouveaunom = null)

$this->verif_get = trim($verif_get);

$this->nouveau_nom = trim($nouveaunom);

$nom_fichier = $this->Nettoie_nom_fichier($nom_local);

if($this->nouveau_nom != null)
	$nom_fichier=$this->nouveau_nom . '.' . strtolower(substr($nom_local,strrpos($nom_local, ".")+1));

try
{
    if(true)
    {		
        throw new Exception('error');
    }
}
catch(Exception $e)
{
    exit($e->getMessage());
}

if(true)
{		
    exit('error');
}

try 
{
    $this->Verif_param();
}
catch(Exception $e)
{
    exit($e->getMessage());
}

Salut,
j'étais pressé et j'ai pas voulu réinventer toute la roue donc je me suis fait une modif' maison, que tu trouveras peut-être crade mais bon ...

faire

try
{
    if(true)
    {		
        throw new Exception('error');
    }
}
catch(Exception $e)
{
    exit($e->getMessage());
}

reviens a faire

if(true)
{		
    exit('error');
}

Ah ben j'espère bien que cela reviens au même parce qu'au début tout était fait selon la seconde syntaxe.
Et puis simplement, j'ai voulu différencier visuellement (pour moi) la gestions des erreurs de configuration webmestre des autres erreurs, d'où cette autre syntaxe qui effectivement n'apporte rien par rapport à la seconde mais qui sert simplement de repère visuel

try
{
    $this->repertoire  = trim($repertoire);
    $this->verif_post = trim($verif_post);
    $this->file_form = trim($file_form);
    $this->verif_get = trim($verif_get);                                                                               
                   
    $this->Verif_param();
    $this->Verif_repertoire($this->repertoire);
}
catch(Exception $e)
{
    exit($e->getMessage());
}

pour la fonction Nettoie_nom_fichier, je suis revenu sur ma position au niveau du iconv (comme quoi ...), j'ai un soucis sur un serveur Debian le iconv venais de la glibc et non de la libiconv, ducoup le TRANSLIT ne marche pas (enfin il existe mais il fais pas grand chose), et je suis toujours a la recherche de la solution miracle...

pour la fonction Nettoie_nom_fichier, je suis revenu sur ma position au niveau du iconv (comme quoi ...), j'ai un soucis sur un serveur Debian le iconv venais de la glibc et non de la libiconv, ducoup le TRANSLIT ne marche pas (enfin il existe mais il fais pas grand chose), et je suis toujours a la recherche de la solution miracle...

merci pour l'info

Bah tu vois, je t'avais dit qu'on observe parfois des pb de compatibilités avec certains serveurs... En fait, suite à tes messages je m'étais dis que ces problèmes n'existaient peut-être plus et j'avais adopté ta méthode après l'avoir testée sur trois serveurs différents, mais bon c'était évidemment pas exhaustif.

Arf du coup dans ma prochaine version je vais revenir à mes vieux tableaux de correspondance, c'est pas beau mais c'est fonctionnel

pour la fonction Nettoie_nom_fichier, je suis revenu sur ma position au niveau du iconv (comme quoi ...), j'ai un soucis sur un serveur Debian le iconv venais de la glibc et non de la libiconv, ducoup le TRANSLIT ne marche pas (enfin il existe mais il fais pas grand chose), et je suis toujours a la recherche de la solution miracle...

merci pour l'info

Bah tu vois, je t'avais dit qu'on observe parfois des pb de compatibilités avec certains serveurs... En fait, suite à tes messages je m'étais dis que ces problèmes n'existaient peut-être plus et j'avais adopté ta méthode après l'avoir testée sur trois serveurs différents, mais bon c'était évidemment pas exhaustif.

Arf du coup dans ma prochaine version je vais revenir à mes vieux tableaux de correspondance, c'est pas beau mais c'est fonctionnel

ouai galère je sais pas si pour la prochaine build ca sera compilé avec avec libiconv, pour l'instant je suis retourné a la méthode de notre ami Gofromiel, c'est bien dommage