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

Méthodes

Change log

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 ====================*/
	/*========================================================================*/
}