/**
 *
 */
 
import flash.filters.GlowFilter;
 
/**
 *
 */
class SlideShow {
	// Espace entre les slides
	var SLIDE_SPACE:Number = 20;
	// Ratio de taille (largeur / hauteur) des slides
	// (ratio type Powerpoint par défaut)
	var SLIDE_RATIO:Number = 4 / 3;

	// Contient les slides chargés (MovieClip)
	var slides:Array;
	
	public function SlideShow() {
		slides = new Array();
		
		initEnv();
		// Diapositives dans le dossier "slides/"
		loadSlides("slides");
	}
	
	// Initialisation de l'environnement
	private function initEnv():Void {
		// Permet de gérer le redimensionnement de la fenêtre manuellement
		Stage.scaleMode = "noScale";

		// Alignement des objets vis-à-vis de la fenêtre principale
		Stage.align = "TL";
		
		// Instanciation d'un observateur de changement de taille
		// de la fenêtre principale
		var refreshStageListener:Object = new Object();
		Stage.addListener(refreshStageListener);
		// Indication de l'élément SlideShow
		refreshStageListener.slideshow = this;
		
		// Mise à jour de l'affichage des slides en cas de redimensionnement
		refreshStageListener.onResize = function() {
			this.slideshow.updateSlides();
		};		
	}
	
	// Chargement de l'ensemble des slides dans un tableau
	private function loadSlides(slideDirectory: String):Void {
		// "Chargeur" des images
		var imageLoader:MovieClipLoader = new MovieClipLoader();

		// Instanciation d'un observateur de chargement des images des slides
		var loadImageListener:Object = new Object();
		imageLoader.addListener(loadImageListener);
		// Indication de l'élément SlideShow
		loadImageListener.slideshow = this;

		// Enregistrement au chargement de l'image
		loadImageListener.onLoadInit = function(image:MovieClip) {
			// Récupération du slide contenant l'image
			var slide:MovieClip = image._parent;
			
			// Animation de la taille et de la position
			slide.onEnterFrame = function() {
				if (this.toX != this._x) {
					if (this.toX - this._x < 1) this._x = this.toX;
					else this._x += (this.toX - this._x) / 4;
				}
				if (this.toY != this._y) {
					if (this.toY - this._y < 1) this._y = this.toY;
					else this._y += (this.toY - this._y) / 4;
				}
				if (this.toWidth != this._width) {
					if (this.toWidth - this._width < 1) this._width = this.toWidth;
					else this._width += (this.toWidth - this._width) / 4;
				}
				if (this.toHeight != this._height) {
					if (this.toHeight - this._height < 1) this._height = this.toHeight;
					else this._height += (this.toHeight - this._height) / 4;
				}
				if (this.toAlpha != this._alpha) {
					if (this.toAlpha - this._alpha < 1) this._alpha = this.toAlpha;
					else this._alpha += (this.toAlpha - this._alpha) / 4;
				}
			};
			
			// Masquage initial du slide
			slide._alpha = 0;
			slide.toAlpha = 100;
			
			// Filtre joli
			slide.filters = [new flash.filters.GlowFilter(0x000000, .15, 
				this.slideshow.SLIDE_SPACE, this.slideshow.SLIDE_SPACE)];
	
			// Sauvegarde du ratio initial de l'image
			image.ratio = image._width / image._height;
			
			// Sauvegarde du slide dans le tableau, à la bonne position
			this.slideshow.slides[slide.slidePosition - 1] = slide;
			
			// Redimensionnement de l'image pour rentrer dans le slide sans déformation
			if (image.ratio < slide._width / slide._height) {
				image._width = slide._width  * image.ratio;
				image._height = slide._width;
			} else {
				image._width = slide._height;
				image._height = slide._height / image.ratio;
			}
			
			// Mise à jour de l'affichage
			this.slideshow.updateSlides();
		};
		
		// Suppression des slide en trop
		loadImageListener.onLoadError = function(image:MovieClip) {
			// Suppression des deux MovieClip
			delete image._parent;
			delete image;
			
			// Suppression du timer
			_root.onEnterFrame = null;
		};
		
		_root.slideNumber = 1;
		_root.imageLoader = imageLoader;
		_root.delay = 200;
		_root.onEnterFrame = function() {
			if (this.lastTime == undefined)
				this.lastTime = getTimer();

			var currentTime:Number = getTimer();
			while (this.lastTime <= currentTime) {
				// Run
				// Url de l'image
				var urlImage:String = slideDirectory + "/Diapositive" + this.slideNumber + ".PNG";
				
				// Création du slide contenant l'image
				var slide:MovieClip = _root.createEmptyMovieClip("slide" + this.slideNumber, _root.getNextHighestDepth());
				// Spécification de la position du slide
				slide.slidePosition = this.slideNumber;
		
				// Création de l'image par chargement par un objet MovieClipLoader
				slide.image = slide.createEmptyMovieClip("slide" + this.slideNumber + "_image", slide.getNextHighestDepth());
				this.imageLoader.loadClip(urlImage, slide.image);
				
				this.slideNumber++;
				// End run
				
				this.lastTime += this.delay;
			}
		};
	}
	
	// Affichage des slides selon leur taille, nombre, ...
	private function updateSlides():Void {
		// Récupération de l'espace "utilisable" dans la fenêtre
		var stageWidth:Number = Stage.width - SLIDE_SPACE * 2;
		var stageHeight:Number = Stage.height - SLIDE_SPACE * 2;
	
		// Aire maximum trouvée
		var areaMax:Number = 0;
		// Nombre de colonnes de slides correspondant à l'aire maximum
		var nbCols:Number = slides.length;
		// Nombre de lignes de slides pour l'aire maximum
		var nbRows:Number = 1;
		// Taille correspondante pour les slides
		var slideWidth:Number = 0;
		var slideHeight:Number = 0;

		// Boucle de "contrainte" :
		// On doit trouver quelle est la configuration en termes
		// de lignes et de colonnes pour laquelle l'aire des slides 
		// est maximum (plus "grand" possible).
		// Pour tous les nombres de slides possibles dans une colonne [1 .. nombre de slides]
		for (var col:Number = this.slides.length; col > 0; col--) {
			// Détermination du nombre de lignes correspondant
			var row:Number = Math.ceil(slides.length / col);
			
			// Calcul de la taille d'un slide sous cette configuration
			var sWidth:Number = Math.max(0, (stageWidth - ((col - 1) * SLIDE_SPACE)) / col);
			var sHeight:Number = Math.max(0, (stageHeight - ((row - 1) * SLIDE_SPACE)) / row);
			// Réajustement de la taille selon le ratio de taille des slides
			if (sWidth / sHeight > SLIDE_RATIO) {
				sWidth = sHeight * SLIDE_RATIO;
				sHeight = sHeight;
			} else {
				sWidth = sWidth;
				sHeight = sWidth / SLIDE_RATIO;
			}
			
			// Calcul de l'aire correspondante
			var area:Number = sWidth * sHeight;
			// Détermination de l'aire maximum et sauvegarde de 
			// la configuration (lignes, colonnes, taille) associée
			if (area > areaMax)
			{
				areaMax = area;
				nbCols = col;
				nbRows = row;
				slideWidth = sWidth;
				slideHeight = sHeight;
			}
		}
		
		// Décalages à effectuer à chaque slide pour obtenir un ensemble centré
		// dans la fenêtre principale
		var offsetX:Number = SLIDE_SPACE + (Stage.width - nbCols * (slideWidth + SLIDE_SPACE) - SLIDE_SPACE) / 2;
		var offsetY:Number = SLIDE_SPACE + (Stage.height - nbRows * (slideHeight + SLIDE_SPACE) - SLIDE_SPACE) / 2;

		// Affichage des slides selon le nombre de lignes et colonnes
		for (var i:Number = slides.length - 1; i >= 0; i--) {
			// Récupération du slide à afficher
			var slide:MovieClip = slides[i];
		
			// Calcul de la ligne et colonne du slide selon sa position dans la liste
			var currCol:Number = i % nbCols;
			var currRow:Number = Math.floor(i / nbCols);
			
			// Spécification de la taille
			slide.toWidth = slideWidth;
			slide.toHeight = slideHeight;

			// Spécification de la position
			slide.toX = offsetX + currCol * (slideWidth + SLIDE_SPACE);
			slide.toY = offsetY + currRow * (slideHeight + SLIDE_SPACE);
		}
	}
	
	// Démarre le programme
	public static function main() {
		var show:SlideShow = new SlideShow();
	}
}