MenuItem.hx | searchcode

/DreamYourGameSDK/src/gui/menu/MenuItem.hx

https://code.google.com/p/dreamyour2dgame/ · Haxe · 559 lines · 412 code · 78 blank · 69 comment · 88 complexity · 433d859206f885bce25934956f2954af MD5 · raw file

package gui.menu;



import flash.display.Bitmap;

import flash.display.BitmapData;

import flash.display.BlendMode;

import flash.display.MovieClip;

import flash.display.Shape;

import flash.display.Sprite;

import flash.events.MouseEvent;

import flash.events.TimerEvent;

import flash.geom.ColorTransform;

import flash.geom.Matrix;

import flash.geom.Point;

import flash.geom.Rectangle;

import flash.Lib;

import flash.text.TextField;

import flash.text.TextFieldAutoSize;

import flash.text.TextFormat;

import flash.text.TextFormatAlign;

import flash.utils.Timer;



import gui.menu.MainMenuItem;

import gui.menu.MenuItemType;

import gui.menu.MenuItemContainerStyle;



/**

 * ...

 * @author Damien Mabin & Birdy

 */

class MenuItem extends Sprite

{

	public static var MAXMENUHEIGHT		: Float = Lib.current.stage.stageHeight;

									

	public var m_Type								: MenuItemType;

	public var m_Key								: String;

	public var m_Father 							: MenuItem;

	public var m_Collapse(default, null)			: Bool;

	public var m_SaveExtendedState(default, null)	: Bool;

	public var m_Style								: { backgroundColor : UInt, backgroundAlpha : Float, borderColor : UInt, borderAlpha : Float, foregroundColor : UInt, foregroundAlpha : Float};			

	public var m_TextFormat							: TextFormat;

	public var m_IsExtendableArrow					: BitmapData;

	public var m_HaveMoreChild						: Sprite;

	public var m_ContainerStyle 					: MenuItemContainerStyle;

	

	private var m_MainBackground 					: Sprite;

	private var m_Label 							: TextField;

	private var m_SeparatorLine						: Bitmap;

	private var m_Child 							: Array<MenuItem>;

	private var m_FirstChildDisplayed				: Int;				//Identifiant dans le tableau des enfant, du premier élément affiché dans le conteneur. 0 Tant que le conteneur affiche tout ses enfants.

	private var m_TimerForItemMove					: Timer;

	private var m_CurrentArrow						: Sprite;

	private var m_ChildContainer					: Sprite;

	private var m_HaveMoreChildUp					: Sprite;

	private var m_HaveMoreChildDown					: Sprite;

	private var m_OverFG 							: Bitmap;

	private var m_IsExtendedFG						: Bitmap;

	

	// ----------------------------------------------------------------------------------------------------------------------------------------

	// PUBLIC FUNCTIONS

	

	public function new(?f_Type : MenuItemType, ?f_Key : String)

	{

		super();

		m_Type = ((f_Type == null) ? CLASSIC : f_Type);

		m_Father = null;

		m_Key = f_Key;

		m_MainBackground = new Sprite();

		m_TextFormat = new TextFormat();

		m_TimerForItemMove = new Timer(0);

		m_Child = new Array<MenuItem>();

		m_SaveExtendedState = false;

		m_Style = MainMenuItem.DEFAULT_STYLE;

		m_ContainerStyle = CASCADE;

		m_FirstChildDisplayed = 0;

		m_ChildContainer = new Sprite();

		

		this.addChild(m_ChildContainer);		

				

		switch(f_Type)

		{

			case CLASSIC :

				m_ChildContainer.visible = false;

				m_ChildContainer.x = MainMenuItem.TREEITEMWIDTH;

				m_Collapse = true;

				

				// Zone affichée quand on a la souris sur le MenuItem

				m_OverFG = new Bitmap(new BitmapData(MainMenuItem.TREEITEMWIDTH - 2 * MainMenuItem.PADDINGSIZE, MainMenuItem.TREEITEMHEIGHT - 2 * MainMenuItem.PADDINGSIZE, false, m_Style.foregroundColor));

				m_OverFG.alpha = m_Style.foregroundAlpha;

				m_OverFG.x = MainMenuItem.PADDINGSIZE; 

				m_OverFG.y = MainMenuItem.PADDINGSIZE;

				m_OverFG.visible = false;

				this.addChild(m_OverFG);

				

				// Zone affichée quand le MenuItem est extended (dans le cas ou les ChildContainer ne sont pas placés en cascade)

				m_IsExtendedFG = new Bitmap(new BitmapData(MainMenuItem.TREEITEMWIDTH - 2 * MainMenuItem.PADDINGSIZE, MainMenuItem.TREEITEMHEIGHT - 2 * MainMenuItem.PADDINGSIZE, false, m_Style.foregroundColor));

				m_IsExtendedFG.alpha = m_Style.foregroundAlpha;

				m_IsExtendedFG.x = MainMenuItem.PADDINGSIZE; 

				m_IsExtendedFG.y = MainMenuItem.PADDINGSIZE;

				m_IsExtendedFG.visible = false;

				this.addChild(m_IsExtendedFG);

				

				// Contenu, texte :

				m_Label = new TextField();

				m_Label.selectable = false;

				m_Label.autoSize = TextFieldAutoSize.LEFT;

				m_Label.text = f_Key;

				m_Label.setTextFormat(m_TextFormat);

				m_Label.y = (MainMenuItem.TREEITEMHEIGHT / 2) - (m_Label.height / 2);

				m_Label.x = MainMenuItem.PADDINGSIZE;

				this.addChild(m_Label);

				

				// Zone de fond :

				m_MainBackground.addChild(new Bitmap(new BitmapData(MainMenuItem.TREEITEMWIDTH, MainMenuItem.TREEITEMHEIGHT, true, 0x00000000)));

				this.addChild(m_MainBackground);

				

				// Ajout des listener

				m_MainBackground.addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);

				m_MainBackground.addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);

				m_MainBackground.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);

			

			case MAIN :

			

			case SEPARATOR :

				// Zone de fond :

				UpdateStyle();				

				this.addChild(m_MainBackground);

			

		}

	}

	

	// Ajoute un fils ŕ l'élément

	public function AddItem(f_ChildItem : MenuItem)

	{

		if (Type.enumEq(m_Type, SEPARATOR))

			throw "YOU CAN'T ADD A CHILD TO A SEPARATOR";

		

		f_ChildItem.y = this.y;

		f_ChildItem.m_Father = this;

		f_ChildItem.m_TextFormat = this.m_TextFormat;

		f_ChildItem.m_Style = this.m_Style;		

		f_ChildItem.m_IsExtendableArrow = this.m_IsExtendableArrow;

		f_ChildItem.m_HaveMoreChild = this.m_HaveMoreChild;

		f_ChildItem.m_SaveExtendedState = this.m_SaveExtendedState;

		f_ChildItem.m_ContainerStyle = this.m_ContainerStyle;

		

		f_ChildItem.UpdateStyle();

		

		// Si c'est le premier enfant qu'on ajoute alors on dessine la petite flčche pour dire qu'il y a des enfants et seulement si l'élément est un élément normal (pas pour le mainMenuItem)

		if ((m_Child.length == 0) && Type.enumEq(m_Type, CLASSIC))

		{

			if ((m_CurrentArrow != null) && this.contains(m_CurrentArrow))				// On supprimer l'ancienne flčche si elle avait déjŕ été dessinée

				this.removeChild(m_CurrentArrow);

			

			m_CurrentArrow = new Sprite();

			m_CurrentArrow.addChild(new Bitmap(m_IsExtendableArrow));

			m_CurrentArrow.x = m_MainBackground.width - (m_IsExtendableArrow.width + MainMenuItem.PADDINGSIZE);

			m_CurrentArrow.y = (m_MainBackground.height / 2) - (m_IsExtendableArrow.height / 2);

			this.addChild(m_CurrentArrow);

		}

		

		// Ajoute le treeItem ŕ la liste des enfants

		m_Child.push(f_ChildItem);

		

		// La position de l'élément dans le conteneur est donnée par la position du précédent dans le ChildContainer (0 s'il n'a pas de précédent)

		f_ChildItem.y = (m_Child.length > 1) ? (m_Child[m_Child.length - 2].y + m_Child[m_Child.length - 2].m_MainBackground.height) : 0;

		

		// On update le ChildContainer

		UpdateChildContainer();

	}

	

	// Supprime le MenuItem

	public function RemoveItem()

	{

		if (m_Father != null)

		{

			m_Father.m_Child.remove(this);

			

			if (m_Father.m_ChildContainer.contains(this))

				m_Father.m_ChildContainer.removeChild(this);			

			

			// Met ŕ jour l'affichage du pčre (le conteneur doit avoir réduit sa taille)

			m_Father.UpdateStyle();

		}

		

		for (i in 0...(this.numChildren))

			removeChild(this.getChildAt(0));

			

		Lambda.iter(m_Child, function(son : MenuItem) { son.RemoveItem(); } );

	}

	

	public function UpdateStyle()

	{

		if (Type.enumEq(m_Type, CLASSIC) || Type.enumEq(m_Type, MAIN))

		{

			if (Type.enumEq(m_Type, CLASSIC))

			{

				m_Label.setTextFormat(m_TextFormat);		

				var labelIsTooBig = (m_Label.textWidth > MainMenuItem.LABELWIDTH - 6); //6 <~=> "...".width

				

				while (m_Label.textWidth > MainMenuItem.LABELWIDTH - 6)

				{

					m_Label.text = m_Label.text.substr(0, m_Label.text.length - 1);

					m_Label.setTextFormat(m_TextFormat);

				}

				if (labelIsTooBig) 

					m_Label.appendText("...");

				

				// On redessine le foreground pour le mouse over et le foreground qui indique si l'item est extended

				m_OverFG.bitmapData = new BitmapData(cast m_OverFG.width, cast m_OverFG.height, false, m_Style.foregroundColor);

				m_OverFG.alpha = m_Style.foregroundAlpha;

				m_IsExtendedFG.bitmapData = new BitmapData(cast m_IsExtendedFG.width, cast m_IsExtendedFG.height, false, m_Style.foregroundColor);

				m_IsExtendedFG.alpha = m_Style.foregroundAlpha;

				

				if (m_Child.length > 0)

				{

					// On supprimer l'ancienne flčche si elle avait déjŕ été dessinée

					if ((m_CurrentArrow != null) && this.contains(m_CurrentArrow))

						this.removeChild(m_CurrentArrow);

					

					m_CurrentArrow = new Sprite();

					m_CurrentArrow.addChild(new Bitmap(m_IsExtendableArrow));

					m_CurrentArrow.x = m_MainBackground.width - (m_IsExtendableArrow.width + MainMenuItem.PADDINGSIZE);

					m_CurrentArrow.y = (m_MainBackground.height / 2) - (m_IsExtendableArrow.height / 2);

					this.addChild(m_CurrentArrow);

				}

			}

			

			UpdateChildContainer();

			

			if ((m_ChildContainer.numChildren == m_Child.length) && (m_HaveMoreChildDown != null) && (m_HaveMoreChildUp != null))

			{

				// Le conteneur est assez grand pour afficher tous les enfants or les Sprite pour scroller sont toujours présents. Il faut donc les enlever et supprimer les listener de scroll.

				this.removeChild(m_HaveMoreChildDown);

				m_HaveMoreChildDown.removeEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);

				m_HaveMoreChildDown = null;

				this.removeChild(m_HaveMoreChildUp);

				m_HaveMoreChildUp.removeEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);

				m_HaveMoreChildUp = null;

				m_ChildContainer.removeEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);				

			}

		}

		else if (Type.enumEq(m_Type, SEPARATOR))

		{

			//Enlčve le bitmap contenant la ligne si il existe

			if (m_MainBackground.numChildren > 0)

				m_MainBackground.removeChild(m_SeparatorLine);

				

			var lineFond = new BitmapData(MainMenuItem.TREEITEMWIDTH, MainMenuItem.SEPARATORHEIGHT, true, m_Style.backgroundColor); //BitmapData contenant la ligne

			

			var line = new Shape();

			line.graphics.beginFill(m_Style.backgroundColor, m_Style.backgroundAlpha);

			line.graphics.lineStyle(1, m_Style.borderColor, m_Style.borderAlpha); //Donne ŕ la ligne le męme style que celui de la bordure des conteneurs

			line.graphics.moveTo(MainMenuItem.PADDINGSIZE * 2, (MainMenuItem.SEPARATORHEIGHT / 2));

			line.graphics.lineTo(MainMenuItem.TREEITEMWIDTH - (MainMenuItem.PADDINGSIZE * 4), (MainMenuItem.SEPARATORHEIGHT / 2));

			

			//Dessine la ligne dans le BitmapData

			lineFond.draw(line);

			

			m_SeparatorLine = new Bitmap(lineFond);			

			m_MainBackground.addChild(m_SeparatorLine);	//Ajoute la ligne au background du TreeElem

		}

		

		for (child in m_Child)

		{

			child.m_Style = this.m_Style;

			child.UpdateStyle();

		}

	}

	

	public function Expand() : Void

	{

		if (m_Collapse)

		{

			// Collapse l'ensemble des frčres de l'élément

			if (m_Father != null)

			{				

				for (i in 0 ... m_Father.m_Child.length)

				{

					if (m_Father.m_Child[i] != this)

					{

						m_Father.m_Child[i].Collapse();

					}

				}

			}			

			

			m_ChildContainer.visible = true;

			if ((m_HaveMoreChildDown != null) && (m_HaveMoreChildUp != null))

				m_HaveMoreChildDown.visible = m_HaveMoreChildUp.visible = true;

				

			m_Collapse = false;

			

			// On marque que l'item est extended

			if (Type.enumEq(m_ContainerStyle, FIXED_ONTOP) && Type.enumEq(m_Type, CLASSIC))

				m_IsExtendedFG.visible = true;

		}

	}

	

	public function Collapse() : Void

	{

		if (!m_Collapse)

		{

			if (!m_SaveExtendedState)

			{

				//Collapse les fils de l'élément

				for (i in 0 ... m_Child.length)

				{

					m_Child[i].Collapse();

				}

			}

			

			m_ChildContainer.visible = false;

			if ((m_HaveMoreChildDown != null) && (m_HaveMoreChildUp != null))

				m_HaveMoreChildDown.visible = m_HaveMoreChildUp.visible = false;

			

			m_Collapse = true;

			

			if (Type.enumEq(m_ContainerStyle, FIXED_ONTOP) && Type.enumEq(m_Type, CLASSIC) && m_IsExtendedFG.visible)

				m_IsExtendedFG.visible = false;

		}

	}

	

	// Retourne le nom complet de l'élément soit la concaténation des m_Key de tous ses ancętres (séparés par des .)

	public function GetFullKey() : String

	{

		if (m_Father == null)

			return m_Key;

		else

			return m_Father.GetFullKey() + "." + m_Key;

	}

	

	// ----------------------------------------------------------------------------------------------------------------------------------------

	// PRIVATE FUNCTIONS

	

	private function mouseOverHandler(f_ME : MouseEvent) : Void

	{

		m_OverFG.visible = true;

    }

	

	private function mouseOutHandler(f_ME : MouseEvent) : Void

	{

		m_OverFG.visible = false;

    }

	

	private function mouseDownHandler(f_ME : MouseEvent) : Void

	{

		if (m_Child.length > 0)

		{

			if (m_Collapse)

			{

				Expand();

			}

			else

			{

				Collapse();

			}

		}

    }

	

	// Update l'affichage du conteneur d'enfants

	private function UpdateChildContainer()

	{

		if (m_Child.length > 0)

		{

			// Place le conteneur au bon endroit

			if (Type.enumEq(m_ContainerStyle, CASCADE))

				m_ChildContainer.y = 0 + (((m_HaveMoreChildDown == null) && (m_HaveMoreChildUp == null)) ? 0 : m_HaveMoreChild.height - 1);

			else

				m_ChildContainer.y = -this.y + (((m_HaveMoreChildDown == null) && (m_HaveMoreChildUp == null)) ? 0 : m_HaveMoreChild.height - 1);

			

			// La hauteur maximum est donnée par MAXMENUHEIGHT, moins les hauteurs des 2 Sprites indiquant la présence d'enfant cachés, moins l'emplacement ou se situe l'origine dans le stage du menuItem

			var maxHeight = MAXMENUHEIGHT - 2 * m_HaveMoreChild.height - this.localToGlobal(new Point()).y;

			

			var lastChild = m_Child[m_Child.length - 1];

			var lastChildHeight = Std.int(m_ChildContainer.localToGlobal(new Point(0, lastChild.y)).y + lastChild.m_MainBackground.height);

			

			// Update l'affichage de l'ExpendShadow si on est sur le MainMenuItem

			if (Type.enumEq(m_Type, MAIN))

			{

				if (cast(this, MainMenuItem).m_ExpendShadow != null) // Si on n'a pas voulu gérer la m_ExpendShadow, celle-ci est encore null

				{

					var shadowHeight = Std.int(lastChild.y + lastChild.m_MainBackground.height);

					cast(this, MainMenuItem).m_ExpendShadow.bitmapData = new BitmapData(cast cast(this, MainMenuItem).m_ExpendShadow.width, shadowHeight, false, 0x111111);

				}

			}

			

			if (lastChildHeight >= maxHeight) // L'item descend plus bas que la hauteur autorisée

			{

				//if ((m_ChildContainer.y - lastChild.m_MainBackground.height) < m_HaveMoreChild.height) // Le ChildContainer est trop grand męme si on l'allonge vers le haut

				//{				

					if ((m_HaveMoreChildDown == null) && (m_HaveMoreChildUp == null))

					{

						m_ChildContainer.y += m_HaveMoreChild.height - 1;

						

						// On n'a pas encore dessiné les shapes indiquant la présence de plus d'éléments que l'on ne peut en afficher

						var imgCartridge = new BitmapData(cast m_HaveMoreChild.width, cast m_HaveMoreChild.height, true, 0x000000);

						imgCartridge.draw(m_HaveMoreChild);

						

						m_HaveMoreChildUp = new Sprite();					

						m_HaveMoreChildUp.addChild(new Bitmap(imgCartridge));

						m_HaveMoreChildUp.rotation = 180;

						m_HaveMoreChildUp.x = m_ChildContainer.x + m_HaveMoreChild.width; // La rotation décale le bitmap d'une largeur vers la gauche

						m_HaveMoreChildUp.y = m_ChildContainer.y + 1;

						m_HaveMoreChildUp.addEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);

						m_HaveMoreChildUp.visible = false;

						this.addChild(m_HaveMoreChildUp);

						

						m_HaveMoreChildDown = new Sprite();

						m_HaveMoreChildDown.addChild(new Bitmap(imgCartridge));

						m_HaveMoreChildDown.x = m_ChildContainer.x;

						m_HaveMoreChildDown.y = m_ChildContainer.y + (m_Child[m_Child.length - 2].y + m_Child[m_Child.length - 2].m_MainBackground.height);

						m_HaveMoreChildDown.addEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);

						m_HaveMoreChildDown.visible = false;

						this.addChild(m_HaveMoreChildDown);

					}

					

					// Listener pour le déroulement des enfants

					m_ChildContainer.addEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);

				//}

				/*else // On remonte vers le haut le ChildContainer, de la hauteur du nouvel élément

				{

					m_ChildContainer.y -= lastChild.m_MainBackground.height;

					

					m_ChildContainer.addChild(lastChild);

				

					// Redessine le fond du conteneur des enfants

					m_ChildContainer.graphics.clear();

					m_ChildContainer.graphics.beginFill(m_Style.backgroundColor, m_Style.backgroundAlpha);

					m_ChildContainer.graphics.lineStyle(1, m_Style.borderColor, m_Style.borderAlpha);

					m_ChildContainer.graphics.drawRect(0, 0, MainMenuItem.TREEITEMWIDTH, (lastChild.y + lastChild.m_MainBackground.height));

				}*/

			}

			else

			{

				if(!m_ChildContainer.contains(lastChild))

					m_ChildContainer.addChild(lastChild);

				

				// Redessine le fond du conteneur des enfants

				m_ChildContainer.graphics.clear();

				m_ChildContainer.graphics.beginFill(m_Style.backgroundColor, m_Style.backgroundAlpha);

				m_ChildContainer.graphics.lineStyle(1, m_Style.borderColor, m_Style.borderAlpha);

				m_ChildContainer.graphics.drawRect(0, 0, MainMenuItem.TREEITEMWIDTH, (lastChild.y + lastChild.m_MainBackground.height));

			}

			

			// Réordonne les items dans le conteneur

			ReplaceAllItemInChildContainer();

		}

		else

		{

			m_ChildContainer.graphics.clear();

		}

	}

	

	// Au passage du curseur sur un ChildContainer (ou sur un Sprite HaveMoreChild), pour effecter le scroll des enfants dans le conteneur

	private function ScrollChildContainer(?f_ME : MouseEvent)

	{

		m_TimerForItemMove.reset();

		

		var current = (m_ChildContainer.mouseY - (m_ChildContainer.height / 2)) / (m_ChildContainer.height / 2);

		

		if (current >= 1)

		{

			//Si la souris est située sur le m_HaveMoreChildDown

			m_TimerForItemMove = new Timer(10);

			m_TimerForItemMove.start();

			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemDown);

		}

		else if (current >= (3 / 4)) 

		{

			//Si la souris est située dans le quart bas du ChildContainer

			m_TimerForItemMove = new Timer(30);

			m_TimerForItemMove.start();

			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemDown);

		}

		else if (current >= (2 / 3)) 

		{

			//Si la souris est située dans le tiers bas du ChildContainer

			m_TimerForItemMove = new Timer(120);

			m_TimerForItemMove.start();

			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemDown);

		}

		else if (current <= -1)

		{

			//Si la souris est située sur le m_HaveMoreChildUp

			m_TimerForItemMove = new Timer(10);

			m_TimerForItemMove.start();

			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemUp);

		}

		else if (current <= -(3 / 4))

		{

			//Si la souris est située dans le quart haut du ChildContainer

			m_TimerForItemMove = new Timer(30);

			m_TimerForItemMove.start();

			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemUp);

		}

		else if (current <= -(2 / 3))

		{

			//Si la souris est située dans le tiers haut du ChildContainer

			m_TimerForItemMove = new Timer(120);

			m_TimerForItemMove.start();

			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemUp);

		}

		else

		{

			m_TimerForItemMove.stop();

		}

	}

	

	// Effectue le scroll des MenuItem vers le bas dans le ChildContainer 

	private function GoChildContainerItemDown(f_te : TimerEvent)

	{

		m_TimerForItemMove.reset();

		m_TimerForItemMove.removeEventListener(TimerEvent.TIMER, GoChildContainerItemDown);

		

		//On vérifie que l'on peut encore se déplacer dans le ChildContainer

		if ((m_FirstChildDisplayed + 1) <= (m_Child.length - m_ChildContainer.numChildren))

		{

			m_FirstChildDisplayed++;

			// On descend vers les items les plus en bas : on remove l'item tout en haut et on add l'item tout en bas

			m_ChildContainer.removeChild(m_Child[m_FirstChildDisplayed - 1]);

			m_ChildContainer.addChild(m_Child[(m_FirstChildDisplayed + m_ChildContainer.numChildren)]);			

			

			ReplaceAllItemInChildContainer();

			// Relance la fonction qui gčre le scroll

			ScrollChildContainer();

		}

	}

	

	// Effectue le scroll des MenuItem vers le haut dans le ChildContainer 

	private function GoChildContainerItemUp(f_te : TimerEvent)

	{

		m_TimerForItemMove.reset();

		m_TimerForItemMove.removeEventListener(TimerEvent.TIMER, GoChildContainerItemUp);

		

		//On vérifie que l'on peut encore se déplacer dans le ChildContainer

		if ((m_FirstChildDisplayed - 1) >= 0)

		{

			m_FirstChildDisplayed--;

			// On monte vers les items les plus en haut : on remove l'item tout en bas et on add l'item tout en haut 

			m_ChildContainer.removeChild(m_Child[m_FirstChildDisplayed + m_ChildContainer.numChildren]);

			m_ChildContainer.addChild(m_Child[m_FirstChildDisplayed]);

			

			ReplaceAllItemInChildContainer();

			// Relance la fonction qui gčre le scroll

			ScrollChildContainer();

		}

	}

	

	// Repositionne les items du childContainer les uns sous les autres en plaçant le FirstDisplay tout en haut

	private function ReplaceAllItemInChildContainer()

	{		

		m_Child[m_FirstChildDisplayed].y = 0;

		for (i in (m_FirstChildDisplayed + 1)...(m_FirstChildDisplayed + m_ChildContainer.numChildren))

		{

			m_Child[i].y = m_Child[i - 1].y + m_Child[i - 1].m_MainBackground.height;

		}		

	}



	

}