Table des matières

com.neolao.controls.StageManager

Gestionnaire du Stage

Exemples

StageManager.initialize(); // par défaut, c'est TL et noScale
 
// Positionner en haut à gauche avec un décalage de _x+50 et _y+20
StageManager.addListener(this.cible1_mc, {align:"TL", _x:50, _y:20}); 
 
// Positionner en haut à droite avec un décalage de _y+20
// La propriété "_height" est égale à Stage.height - 20
StageManager.addListener(this.cible2_mc, {align:"TR", _y:20, pHeight:"_height", height: -20});
 
 
// Positionner en bas au milieu
// Lancer la fonction toto à chaque redimensionnement du Stage
var toto:Function = function(){
	this._width = Stage.width / 2;
};
StageManager.addListener(this.cible3_mc, {align:"B", onResize:toto});

Propriétés

Visibilité Type Nom Status Description
static public Number minWidth La largeur minimale de l'interface
static public Number maxWidth La largeur maximale de l'interface
static public Number minHeight La hauteur minimale de l'interface
static public Number maxHeight La hauteur maximale de l'interface

Méthodes

Visibilité Return Nom Param 1 Param 2 Description
static public Void initialize pAlign:String pScaleMode:String Initialise le Stage
static public Boolean addListener pInstance:Object pParam:Object Ajoute une instance à la liste des objets
static public Boolean removeListener pInstance:Object Supprime une instance de la liste des objets
static public Void update Met à jour toutes les instances sur la scène qui ont été répertoriée

Change log

[28/07/2004] Version 1.4

Création

[27/09/2004] Version 1.5

Ajout des minimums hauteur et largeur

[30/09/2004] Version 1.6

Modification de initialize

[31/12/2004] Version 1.7

Ajout des maximums hauteur et largeur

[25/02/2005] Version 1.8

Mise à jour des méthodes :

  • update: je supprime les instances automatiquement pendant une update si elles n'existent plus

[22/04/2005] Version 1.9

Modification de la méthode initialize :

  • ajout d'un paramètre optionnel, le scaleMode

[20/06/2005] Version 2.0

ajout d'un paramètre optionnel pour les MovieClip “onResize” qui sert à lancer une fonction à la fin du positionnement

[23/06/2005] Version 2.1

Bug dans la méthode removeListener, il enlevait tous les clips au lieu d'un seul

Source

/**
 * @description 	Gestionnaire du Stage
 * @author 		neolao <neo@neolao.com>
 * @version 		2.1 (23/06/2005)
 * @link		http://resources.neolao.com/flash/classes/controls/StageManager
 */
dynamic class com.neolao.controls.StageManager {
	public static var className:String = "StageManager";
	public static var version:String = "2.1";
 
	// ----------------------------- VARIABLES ---------------------------------
	/**
	 * La largeur minimale de l'interface
	 */
	private static var _minWidth:Number;
	/**
	 * La hauteur minimale de l'interface
	 */
	private static var _minHeight:Number;
	/**
	 * La largeur maximale de l'interface
	 */
	private static var _maxWidth:Number;
	/**
	 * La hauteur maximale de l'interface
	 */
	private static var _maxHeight:Number;
	/**
	 * Ecouteur du Stage
	 */
	private static var _listener:Object;
	/**
	 * Liste des instances répertoriées
	 */
	private static var _instances:Array;
 
	// ----------------------------- EVENEMENTS --------------------------------
	/**
	 * Evénement invoqué avant l'update
	 */
	public static var onBeforeResize:Function;
	/**
	 * Evénement invoqué après l'update
	 */
	public static var onResize:Function;
 
 
	/*=========================== METHODES PRIVEES ===========================*/
	/*========================================================================*/
	/**
	 * Cherche une instance et retourne l'objet lui correspondant, sinon null
	 * @param pInstance L'instance à rechercher
	 * @return L'objet contenant l'instance
	 */
	private static function _searchInstance(pInstance:Object):Object{
		var i:Object;
 
		for(i in _instances){
			if(_instances[i].instance == pInstance){
				return _instances[i];
			}
		}
		return null;
	}
	/**
	 * Surcharge les propriétés d'un objet
	 */
	private static function _addProperties(pObject:Object, pProperties:Object){
		for(var i in pProperties){
			pObject[i] = pProperties[i];
		}
	}
	/**
	 * Initialise les propriétés d'un objet
	 */
	private static function _initProperties(pObject:Object){
		pObject.align = "";
		pObject._x = 0;
		pObject._y = 0;
		pObject.width = 0;
		pObject.height = 0;
	}
	/**
	 * Ajoute une instance à la liste des objets
	 */
	private static function _addInstance(pInstance:Object, pParam:Object, pType:String):Boolean{
		var vObject:Object;
		var vResult:Boolean = Boolean(vObject = _searchInstance(pInstance));
 
		if(!vResult){
			// Si l'instance n'est pas déjà dans la liste
			vObject = new Object();
			vObject.instanceType = pType;
			vObject.instance = pInstance;
			_initProperties(vObject);
 
			_addProperties(vObject, pParam);
			_instances.push(vObject);
		}else{
			// L'instance est déjà dans la liste
			_addProperties(vObject, pParam);
		}
		update();
		return vResult;
	}
	/**
	 * update l'instance de type MovieClip
	 */
	private static function updateMovieClip(pObject:Object){
		var vDecaleX:Number;
		var vDecaleY:Number;
		var vLeft:Boolean = (Stage.align.indexOf("L") != -1);
		var vTop:Boolean = (Stage.align.indexOf("T") != -1);
		var vHorizontalCenter:Boolean = (!vLeft && (Stage.align.indexOf("R") == -1));
		var vVerticalCenter:Boolean = (!vTop && (Stage.align.indexOf("B") == -1));
		var vTargetLeft:Boolean;
		var vTargetTop:Boolean;
		var vTargetHorizontalCenter:Boolean;
		var vTargetVerticalCenter:Boolean;
		var vObject:Object = pObject;
		var vStageWidth:Number = Stage.width;
		var vStageHeight:Number = Stage.height;
 
		vTargetLeft = (vObject.align.indexOf("L") != -1);
		vTargetTop = (vObject.align.indexOf("T") != -1);
		vTargetHorizontalCenter = (!vTargetLeft && (vObject.align.indexOf("R") == -1));
		vTargetVerticalCenter = (!vTargetTop && (vObject.align.indexOf("B") == -1));
 
		// Gestion du Stage limit
		if(Stage.width < _minWidth){
			vStageWidth = _minWidth;
		}
		if(Stage.height < _minHeight){
			vStageHeight = _minHeight;
		}
		if(Stage.width > _maxWidth && _maxWidth > 0){
			vStageWidth = _maxWidth;
		}
		if(Stage.height > _maxHeight && _maxHeight > 0){
			vStageHeight = _maxHeight;
		}
 
		// Decalage X
		if(vHorizontalCenter){
			// Ni Left ni Right
			if(vTargetHorizontalCenter){
				// Target Center
				vDecaleX = 0;
			}else if(vTargetLeft){
				// Target Left
				vDecaleX = - vStageWidth / 2;
			}else{
				// Target Right
				vDecaleX = vStageWidth / 2;
			}
		}else if(vLeft){
			// Left
			if(vTargetHorizontalCenter){
				// Target Center
				vDecaleX = vStageWidth / 2;
			}else if(vTargetLeft){
				// Target Left
				vDecaleX = 0;
			}else{
				// Target Right
				vDecaleX = vStageWidth;
			}
		}else{
			// Right
			if(vTargetHorizontalCenter){
				// Target Center
				vDecaleX = - vStageWidth / 2;
			}else if(vTargetLeft){
				// Target Left
				vDecaleX = - vStageWidth;
			}else{
				// Target Right
				vDecaleX = 0;
			}
		}
 
		// Decalage Y
		if(vVerticalCenter){
			// Ni Top ni Bottom
			if(vTargetVerticalCenter){
				// Target Center
				vDecaleY = 0;
			}else if(vTargetTop){
				// Target Top
				vDecaleY = - vStageHeight / 2;
			}else{
				// Target Bottom
				vDecaleY = vStageHeight / 2;
			}
		}else if(vTop){
			// Top
			if(vTargetVerticalCenter){
				// Target Center
				vDecaleY = vStageHeight / 2;
			}else if(vTargetTop){
				// Target Top
				vDecaleY = 0;
			}else{
				// Target Bottom
				vDecaleY = vStageHeight;
			}	
		}else{
			// Bottom
			if(vTargetVerticalCenter){
				// Target Center
				vDecaleY = - vStageHeight / 2;
			}else if(vTargetTop){
				// Target Top
				vDecaleY = - vStageHeight;
			}else{
				// Target Bottom
				vDecaleY = 0;
			}
		}
 
		vObject.instance._x = vDecaleX + (vObject._x || 0);
		vObject.instance._y = vDecaleY + (vObject._y || 0);
 
		// param width
		if(vObject.width != 0){
			vObject.instance[vObject.pWidth] = vStageWidth + vObject.width;
		}
		// param height
		if(vObject.height != 0){
			vObject.instance[vObject.pHeight] = vStageHeight + vObject.height;
		}
		// param onResize
		if(vObject.onResize){
			vObject.onResize.apply(vObject.instance);
		}
	}
	/*===================== FIN = METHODES PRIVEES = FIN =====================*/
	/*========================================================================*/
 
	/*============================ GETTER  SETTER ============================*/
	/*========================================================================*/
	/**
	 * La largeur minimale de l'interface
	 */
	public static function set minWidth(pWidth:Number){
		_minWidth = pWidth;
	}
	public static function get minWidth():Number{
		return _minWidth;
	}
	/**
	 * La hauteur minimale de l'interface
	 */
	public static function set minHeight(pHeight:Number){
		_minHeight = pHeight;
	}
	public static function get minHeight():Number{
		return _minHeight;
	}
	/**
	 * La largeur maximale de l'interface
	 */
	public static function set maxWidth(pWidth:Number){
		_maxWidth = pWidth;
	}
	public static function get maxWidth():Number{
		return _maxWidth;
	}
	/**
	 * La hauteur maximale de l'interface
	 */
	public static function set maxHeight(pHeight:Number){
		_maxHeight = pHeight;
	}
	public static function get maxHeight():Number{
		return _maxHeight;
	}
	/*====================== FIN = GETTER  SETTER = FIN ======================*/
	/*========================================================================*/
 
	/*========================== METHODES PUBLIQUES ==========================*/
	/*========================================================================*/
	/**
	 * Initialise le Stage
	 * @param pAlign align [option="TL"]
	 * @param pScaleMode scaleMode [option="noScale"]
	 */
	public static function initialize(pAlign:String, pScaleMode:String){
		Stage.scaleMode = (pScaleMode == undefined)?"noScale":pScaleMode;
		Stage.align = (pAlign == undefined)?"TL":pAlign;
 
		_instances = new Array();
		_listener = new Object();
		_listener.onResize = function(){
			StageManager.onBeforeResize();	
			StageManager.update();
			StageManager.onResize();
		};
		Stage.addListener(_listener);
	}
	/**
	 * Ajoute une instance à la liste des objets
	 * @param pInstance L'instance à modifier à l'événement onResize
	 * @param pParam Les paramètres de modification
	 * @return false si l'instance était déjà dans la liste, sinon true
	 */
	public static function addListener(pInstance:Object, pParam:Object):Boolean{
		return _addInstance(pInstance, pParam, "MovieClip");
	}
	/**
	 * Ajoute une instance TextField à la liste des objets
	 * @param pInstance L'instance à modifier à l'événement onResize
	 * @param pParam Les paramètres de modification
	 * @return false si l'instance était déjà dans la liste, sinon true
	 */
	public static function addTextField(pInstance:Object, pParam:Object):Boolean{
		return _addInstance(pInstance, pParam, "TextField");
		// pour l'instant, cette structure ne sert à rien, mais on sait jamais ...
	}
	/**
	 * Supprime une instance de la liste des objets
	 * @param pInstance L'instance à supprimer à l'événement onResize
	 * @return true si l'instance existait dans la liste des objets, sinon false
	 */
	public static function removeListener(pInstance:Object):Boolean{
		var vObject:Object;
		var vResult:Boolean = Boolean(vObject = _searchInstance(pInstance));
		var i:Number = 0;
 
		if(vResult){
			// L'instance est dans la liste
			while(_instances[i].instance != vObject && i < _instances.length){
				i++;
			}
			_instances.splice(i, 1);
		}
		return vResult;
	}
	/**
	 * Met à jour toutes les instances sur la scène qui ont été répertoriée
	 */
	public static function update(){
		var vInstance:Object;
 
		for(var i in _instances){
			vInstance = _instances[i];
			if(vInstance.instance.getDepth() == undefined){
				removeListener(vInstance);
			}else{
				switch(vInstance.instanceType){
					case "TextField":
 
						break;
					default:
					case "MovieClip":
						updateMovieClip(vInstance);
				}
			}
		}
	}
	/*==================== FIN = METHODES PUBLIQUES = FIN ====================*/
	/*========================================================================*/
}