//----------------------------------------------------------------------------------
//
//                              Transition V1.4
//
//				Bestmomo Lagan
//
//----------------------------------------------------------------------------------
//
// Nouveautés V1.1 => Mise en place modes Dark et Fast et optimisation code
// Nouveautés V1.2 => Mise en place mode Swap horizontal
// Nouveautés V1.3 => Mise en place mode Swap diagonal et intégration du code de construction
// Nouveautés V1.4 => Mise en place modes Circle, Grow et Random
//
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
//                              LIBRARY FUNCTIONS
//----------------------------------------------------------------------------------

// -- Génération d'un entier aléatoire --
// @ param [integer] Valeur maximale
// @ return [integer] entier aléatoire
integer RandInt(integer n) {return (integer)llFrand(n + 1);
}
// -- Création d'un entier aléatoire --
// @ param [integer] Valeur mini
// @ param [integer] Valeur maxi
// @ return [integer] Valeur aléatoire
integer RandIntBetween(integer min, integer max) {
	return min + RandInt(max - min);
}
// -- Passage de glogal à local --
// @ param [vector] Position globale
// @ return [vector] Position locale
vector Global2Local(vector position) {
	return (position - llGetRootPosition()) / llGetRootRotation();}

//---------------------------------------------------------------
//                        MENU FUNCTIONS
//---------------------------------------------------------------

// -- Initialisation menu --
// @ param [key] 	clé de l'avatar
// @ param [string] texte pour le menu
// @ param [list] noms des boutons
// @ param [integer] type de menu
InitMenu(key id, string texte, list boutons, integer typemenu) {
	// Mise en route du timer
	if(iMode == MODE_OFF) llSetTimerEvent(TIMEOUT);
	llResetTime();
	// Enregistrement des paramètres
	lBoutonsMenu = boutons;
	iCanalMenu = GetRandomChannel();
	sTexteMenu = texte;
	iIndexMenu = 0;
	iBusy = TRUE;
	iTypeMenu = typemenu;
	kAvaMenu = id;
	// Mise en place et enregistrement de l'écoute
	iEcouteMenu = llListen(iCanalMenu, "", id, "");
	// Envoi du menu
	GestMenu();
}

// -- Gestion de l'index des boutons du menu --
// @ param [string] bouton de déplacement
GestIndexBoutons(string browse) {
	// Nombre de boutons
	integer n = llGetListLength(lBoutonsMenu);
	// Navigation simple pour deux pages
	if(iIndexMenu) iIndexMenu = 0;
	else iIndexMenu = 11;
	// Mise en route du timer
	if(iMode == MODE_OFF) llSetTimerEvent(TIMEOUT);
	llResetTime();
	// Envoi du menu
	GestMenu();
}

//	-- Gestion menu --
GestMenu() {
	// Liste globale des boutons
	list lBoutons = lBoutonsMenu;
	// Nombre total de boutons
	integer n = llGetListLength(lBoutonsMenu);
	// Si plusieurs pages
	if(n > 12) {
		// Que 2 pages -> navigation simple
		// Deuxième page
		if(iIndexMenu)
			lBoutons = [PREVIOUS] + llList2List(lBoutonsMenu, iIndexMenu, -1);
		// Première page
		else
			lBoutons = llList2List(lBoutonsMenu, 0, 1) + [NEXT] + llList2List(lBoutonsMenu, 2, 10);}
	// Envoi du menu
	llDialog(kAvaMenu, sTexteMenu, lBoutons, iCanalMenu);
}

// -- Suppression d'un menu --
CancelMenu() {
	// On teste s'il y a quelque chose à arrêter
	if(iEcouteMenu) {
		// Arrêt de l'écoute du canal
		llListenRemove(iEcouteMenu);
		iEcouteMenu = 0;
		// Libération du menu
		iBusy = FALSE;
		// On arrête le timer
		if(iMode == MODE_OFF) llSetTimerEvent(.0);}
}

// -- Fin du délai d'écoute des menu --
FinMenu() {
	// On prévient l'avatar
	llInstantMessage(kAvaMenu, "Time out for dialog.");
	// On supprime le menu
	CancelMenu();
}

// -- Fonction qui génère un canal au hasard (négatif) --
// @ return [integer] retourne le canal
integer GetRandomChannel() {
	return ~(integer)llFrand((float)DEBUG_CHANNEL);
}


//----------------------------------------------------------------------------------
//                        LIBRARY VARIABLES
//----------------------------------------------------------------------------------

//----------------------------------------------
//                  MENUS
//----------------------------------------------
string	PREVIOUS		= "<<<";	// Bouton pour page arrière
string	NEXT			= ">>>";	// Bouton pour page avant
float	TIMEOUT			= 60.0;		// Délai pour réponse au menu

integer	iCanalMenu;					// Canaux du Chat
integer	iEcouteMenu;				// Handle de l'écoute
integer	iIndexMenu;					// Index de position dans les boutons
integer	iTypeMenu;					// Type de menu
integer	iBusy;						// Menu occupé
string  sTexteMenu;					// Texte pour le menu
list	lBoutonsMenu;				// Boutons du menu
key		kAvaMenu;					// Clé de l'avatar

//----------------------------------------------------------------------------------
//                               SCRIPT FUNCTIONS
//----------------------------------------------------------------------------------

//----------------------------------------------
//                  MENUS
//----------------------------------------------

// -- Création du menu général --
// @ param [key] clé de l'avatar
Menu_Main(key id) {
	list l = MENU_MAIN;
	// Bouton marche/arrêt
	if(iMode != MODE_OFF) l += "Off";
	// Modes
	if(iMode != MODE_DARK_SHOW && iMode != MODE_DARK_TRANS)
		l += "Dark";
	if(iMode != MODE_FUSION_SHOW && iMode != MODE_FUSION_TRANS)
		l += "Fusion";
	if(iMode != MODE_SWAPH_SHOW && iMode != MODE_SWAPH_TRANS)
		l += "Swap H";
	if(iMode != MODE_SWAPD_SHOW && iMode != MODE_SWAPD_TRANS)
		l += "Swap D";
	if(iMode != MODE_CIRCLE_SHOW && iMode != MODE_CIRCLE_TRANS)
		l += "Circle";
	if(iMode != MODE_GROW_SHOW && iMode != MODE_GROW_TRANS)
		l += "Grow";
	if(iMode != MODE_FAST_SHOW)
		l += "Fast";
	if(!iRandomShow)
		l += "Random";
	// Affichage du menu
	InitMenu(id, "\nSelect an option", l, TYPE_MENU_MAIN);
}

// -- Menu Settings --
Menu_Settings(key id) {
	list l = MENU_SETTINGS;
	// Mode Random ou Order
	if(iRandom) l += "Order";
	else l += "Random";
	// Access si owner
	if(id == llGetOwner()) l += "Access";
	// Affichage du menu
	InitMenu(id, "\nSelect an option", l, TYPE_MENU_SETTINGS);
}

// -- Menu d'accès --
Menu_Access(key id) {
	integer i = llListFindList(ACCESS, [sAccess]);
	InitMenu(id, "\nAccess is now " + sAccess + "\n\nSelect another access",
		["Back","Exit"] + llDeleteSubList(ACCESS, i, i), TYPE_MENU_ACCESS);
}

// -- Menu Time --
// @ param [key] clé de l'avatar
// @ param [float] valeur actuelle de a durée
// @ param [string] message
// @ param [integer] type de menu
Menu_Time(key id, float value, string message, integer type_menu) {
	// Représentation string de la valeur de la durée
	string s = (string)((integer)value) + "s";
	// Ajustement du menu
	integer i = llListFindList(MENU_TIME, [s]);
	list l = llDeleteSubList(MENU_TIME, i, i);
	// Affichage du menu
	InitMenu(id, message + (string)((integer)value) + " seconds", l, type_menu);
}

//----------------------------------------------
//                  AUTRES
//----------------------------------------------

// -- Construction de l'écran --
// @ return [interger] TRUE ou FALSE
integer Build() {
	// Test présence 2 primtives
	if(llGetNumberOfPrims() == 2) {
		llSetPrimitiveParams([PRIM_COLOR, ALL_SIDES, <.4,.4,.4>, 1.0,
			PRIM_TYPE, PRIM_TYPE_BOX, 0, <.0, 1.0, 0.0>, 0.0, <0.0, 0.0, 0.0>, <1.0, 1.0, 0.0>, <0.0, 0.0, 0.0>,
			PRIM_COLOR, 0, <1.0,1.0,1.0>, 1.0,
			PRIM_TEXTURE, ALL_SIDES, "819d87ad-913d-37a7-1edf-d269f3bbb624", <8.9,.8,0.0>, <0.0,0.0,0.0>,0.0,
			PRIM_TEXTURE, 0, "819d87ad-913d-37a7-1edf-d269f3bbb624", <1.0,1.0,.0>, <0.0,0.0,0.0>,0.0,
			PRIM_FULLBRIGHT, 0, TRUE,
			PRIM_ROTATION, llEuler2Rot(<270.0, 0, 180.0> * DEG_TO_RAD),
			PRIM_SIZE, <2.0,1.5,.06812>,
			PRIM_TYPE, PRIM_TYPE_BOX, 0, <0.0, 1.0, 0.0>, 0.0, <0.0, 0.0, 0.0>, <.9, .9, 0.0>, <0.0, 0.0, 0.0>]);
		llSetLinkPrimitiveParams(2,[PRIM_COLOR, ALL_SIDES, <.4,.4,.4>, 1.0,
			PRIM_TYPE, PRIM_TYPE_BOX, 0, <.0, 1.0, 0.0>, 0.0, <0.0, 0.0, 0.0>, <1.0, 1.0, 0.0>, <0.0, 0.0, 0.0>,
			PRIM_COLOR, 0, <1.0,1.0,1.0>, 1.0,
			PRIM_TEXTURE, ALL_SIDES, "819d87ad-913d-37a7-1edf-d269f3bbb624", <8.9,.8,0.0>, <0.0,0.0,0.0>,0.0,
			PRIM_TEXTURE, 0, "819d87ad-913d-37a7-1edf-d269f3bbb624", <1.0,1.0,.0>, <0.0,0.0,0.0>,0.0,
			PRIM_FULLBRIGHT, 0, TRUE,
			PRIM_POSITION, <.0,.0,.002>,
			PRIM_ROTATION, llEuler2Rot(<270.0, 0, 180.0> * DEG_TO_RAD),
			PRIM_SIZE, <1.8,1.35,.06812>,
			PRIM_TYPE, PRIM_TYPE_BOX, 0, <0.0, 1.0, 0.0>, 0.0, <0.0, 0.0, 0.0>, <1.0, 1.0, 0.0>, <0.0, 0.0, 0.0>]);
		return TRUE;}
	else {
		llOwnerSay("I cant build screen ! I need 2 linked prims to work !");
		return FALSE;
	}
}

// -- Test des droits d'accès --
// @ param [key] clé de l'avatar
// @ return [interger] TRUE ou FALSE
integer TestAccess(key id) {
	if(sAccess == "Owner" && llGetOwner() == id) return TRUE;
	else if(sAccess == "Group" && llSameGroup(id)) return TRUE;
	else if(sAccess == "All") return TRUE;
	else return FALSE;
}

// -- Test présence au moins 3 images --
// @ return [integer] TRUE ou FALSE
integer Test_3_Images() {
	integer i = llGetInventoryNumber(INVENTORY_TEXTURE) > 2;
	if(i) return TRUE;
	else {
		llSay(0, "Sorry i need at least 3 textures to work !");
		return FALSE;
	}
}

// -- Mise en place d'une texture --
// @ param [integer] numéro primitive
// @ param [integer] face primitive
// @ param [integer] index texture
Place_Texture(integer prim, integer face, integer idTexture) {
	llSetLinkTexture(prim, llGetInventoryName(INVENTORY_TEXTURE, idTexture), face);
}

// -- Mise en place initiale --
Init() {
	if(Test_3_Images()) {
		// Fonctionnement ordonné
		lTextures = [0,1,2];
		iIndex = 2;
		// Mise en place des textures
		Place_Texture(PRIM_ECRAN, FACE_ECRAN, llList2Integer(lTextures, 0));
		Place_Texture(PRIM_BASE, FACE_BASE, llList2Integer(lTextures, 1));
		Place_Texture(PRIM_ECRAN, FACE_PRELOAD, llList2Integer(lTextures, 2));
		// Reset global au cas où
		llSetLinkAlpha(PRIM_ECRAN, 1.0, FACE_ECRAN);
		llSetLinkColor(PRIM_ECRAN, <1.0, 1.0, 1.0>, FACE_ECRAN);}
}

// --  Mise en route --
// @ param [integer] mode de fonctionnement
// @ param [integer] TRUE si timer nécessaire
Go(integer mode, integer time) {
	if(Test_3_Images()) {
		iMode = mode;
		iRequest = CHANGE_NULL;
		// Mise en marche du timer
		if(time) llSetTimerEvent(fTimeShow);}
}

// -- Initialisation de la transition --
// @ param [integer] Mode de fonctionnement
Init_Change(integer	mode) {
	// Changement du mode
	iMode = mode;
	// Calcul du pas
	fPas = fTempsBase / fTimeTrans;
	// Spécificités du mode Dark
	if(iMode == MODE_DARK_TRANS) {
		fPas *= 2.0;
		iSens = TRUE;}
	// Initialisation
	if(iMode == MODE_CIRCLE_TRANS || iMode == MODE_GROW_TRANS)
		fValeur = .0;
	else
		fValeur = 1.0;
	// Réglage timer
	llSetTimerEvent(fTempsBase);
}

// -- Changement d'image --
Change() {
	// Mode Fusion
	if(iMode == MODE_FUSION_TRANS) {
		// Diminution de l'alpha de l'écran
		fValeur -= fPas;
		if(fValeur >= .0)
			llSetLinkAlpha(PRIM_ECRAN, fValeur, FACE_ECRAN);
		else {
			// Réglage du timer
			llSetTimerEvent(fTimeShow);
			// Mise en place image sur l'écran
			Place_Texture(PRIM_ECRAN, FACE_ECRAN, llList2Integer(lTextures, 1));
			// Petit délai de chargement
			llSleep(.2);
			// Affichage de l'écran
			llSetLinkAlpha(PRIM_ECRAN, 1.0, FACE_ECRAN);
			// Chargement des textures
			Charge_Textures();
			// Changement du mode
			if(!Test_Request())
				iMode = MODE_FUSION_SHOW;
		}
	}
	// Mode Swap H
	if(iMode == MODE_SWAPH_TRANS) {
		// Diminution de la largeur et déplacement de l'écran
		fValeur -= fPas;
		if(fValeur > .0) {
			float fLargeur = vEcran_size.x * fValeur;
			vector vSize = <fLargeur, vEcran_size.y, vEcran_size.z>;
			vector vPos = <vEcran_pos.x + (vEcran_size.x - fLargeur) / 2.0, vEcran_pos.y, vEcran_pos.z>;
			float fDecalage = (fValeur - 1.0) / 2.0;
			llSetLinkPrimitiveParamsFast(PRIM_ECRAN, [
				PRIM_SIZE, vSize,
				PRIM_POSITION, vPos,
				PRIM_TEXTURE, FACE_ECRAN, llGetInventoryName(INVENTORY_TEXTURE, llList2Integer(lTextures, 0)),
				<fValeur, 1.0, .0>, <fDecalage, .0, .0>, .0]);
		}
		else {
			Reset_Ecran();
			// Changement du mode
			if(!Test_Request()) iMode = MODE_SWAPH_SHOW;}
	}
	// Mode Swap D
	if(iMode == MODE_SWAPD_TRANS) {
		// Diminution largeur et hauteur et déplacement de l'écran
		fValeur -= fPas;
		if(fValeur > .0) {
			float fLargeur = vEcran_size.x * fValeur;
			float fHauteur = vEcran_size.y * fValeur;
			vector vSize = <fLargeur, fHauteur, vEcran_size.z>;
			vector vPos = <vEcran_pos.x + (vEcran_size.x - fLargeur) / 2.0,
				vEcran_pos.y + (vEcran_size.y - fHauteur) / 2.0,
				vEcran_pos.z>;
			float fDecalage = (fValeur - 1.0) / 2.0;
			llSetLinkPrimitiveParamsFast(PRIM_ECRAN, [
				PRIM_SIZE, vSize,
				PRIM_POSITION, vPos,
				PRIM_TEXTURE, FACE_ECRAN, llGetInventoryName(INVENTORY_TEXTURE, llList2Integer(lTextures, 0)),
				<fValeur, fValeur, .0>, <fDecalage, fDecalage, .0>, .0]);
		}
		else {
			Reset_Ecran();
			// Changement du mode
			if(!Test_Request()) iMode = MODE_SWAPD_SHOW;}
	}
	// Mode Circle
	if(iMode == MODE_CIRCLE_TRANS) {
		fValeur += fPas;
		if(fValeur < 1.0) {
			llSetLinkPrimitiveParamsFast(PRIM_ECRAN, [
				PRIM_TYPE, PRIM_TYPE_BOX, 0, <fValeur, 1.0, 0.0>, 0.0, <0.0, 0.0, 0.0>, <1.0, 1.0, 0.0>, <0.0, 0.0, 0.0>]);
		}
		else {
			Reset_Ecran();
			// Changement du mode
			if(!Test_Request()) iMode = MODE_CIRCLE_SHOW;}
	}
	// Mode Grow
	if(iMode == MODE_GROW_TRANS) {
		fValeur += fPas;
		if(fValeur <= .95) {
			llSetLinkPrimitiveParamsFast(PRIM_ECRAN, [
				PRIM_TYPE, PRIM_TYPE_BOX, 0, <.0, 1.0, 0.0>, fValeur, <0.0, 0.0, 0.0>, <1.0, 1.0, 0.0>, <0.0, 0.0, 0.0>]);
		}
		else {
			Reset_Ecran();
			// Changement du mode
			if(!Test_Request()) iMode = MODE_GROW_SHOW;}
	}
	// Mode Dark
	else if(iMode == MODE_DARK_TRANS) {
		// Premier sens (noircissement)
		if(iSens) {
			fValeur -= fPas;
			if(fValeur >= .0)
				llSetLinkColor(PRIM_ECRAN, <fValeur, fValeur, fValeur>, FACE_ECRAN);
			else {
				// Changement sens
				iSens = FALSE;
				// Mise en place image sur l'écran
				Place_Texture(PRIM_ECRAN, FACE_ECRAN, llList2Integer(lTextures, 1));
				// Chargement des textures
				Charge_Textures();
			}
		}
		// Sens retour (éclaircissement)
		else {
			fValeur += fPas;
			if(fValeur <= 1.0)
				llSetLinkColor(PRIM_ECRAN, <fValeur, fValeur, fValeur>, FACE_ECRAN);
			else {
				// Réglage du timer
				llSetTimerEvent(fTimeShow);
				// Changement du mode
				if(!Test_Request())
					iMode = MODE_DARK_SHOW;
			}
		}
	}
	// Mode Fast
	else if(iMode == MODE_FAST_SHOW) {
		if(!Test_Request()) {
			// Réglage du timer
			llSetTimerEvent(fTimeShow);
			// Mise en place image sur l'écran
			Place_Texture(PRIM_ECRAN, FACE_ECRAN, llList2Integer(lTextures, 1));
			// Chargement des textures
			Charge_Textures();
		}
	}
}

// -- Reset écran pour modes Swap, Circle et Grow --
Reset_Ecran() {
	// Réglage du timer
	llSetTimerEvent(fTimeShow);
	// Effacement de l'écran
	llSetLinkAlpha(PRIM_ECRAN, .0, FACE_ECRAN);
	// Redimensionnement et intégrité de l'écran et affichage
	llSetLinkPrimitiveParamsFast(PRIM_ECRAN, [PRIM_SIZE, vEcran_size,
		PRIM_POSITION, vEcran_pos,
		PRIM_TYPE, PRIM_TYPE_BOX, 0, <.0, 1.0, 0.0>, 0.0, <0.0, 0.0, 0.0>, <1.0, 1.0, 0.0>, <0.0, 0.0, 0.0>,
		PRIM_TEXTURE, FACE_ECRAN, llGetInventoryName(INVENTORY_TEXTURE, llList2Integer(lTextures, 1)),
		<1.0, 1.0, .0>, <1.0, .0, .0>, .0]);
	// Petit délai
	llSleep(1.0);
	// Affichage de l'écran
	llSetLinkAlpha(PRIM_ECRAN, 1.0, FACE_ECRAN);
	// Chargement des textures
	Charge_Textures();
}

// -- Chargement des textures --
Charge_Textures() {
	// Nombre de textures
	integer n = llGetInventoryNumber(INVENTORY_TEXTURE) - 1;
	// Mise en place image sur la face cachée
	Place_Texture(PRIM_BASE, FACE_BASE, llList2Integer(lTextures, 2));
	// Mise à jour de la liste des textures
	lTextures = llListReplaceList(lTextures, llList2List(lTextures, 1, 2), 0, 1);
	lTextures = llDeleteSubList(lTextures, 2, 2);
	// Fonctionnement aléatoire
	if(iRandom) {
		integer p = RandInt(n);
		while(~llListFindList(lTextures, [p])) p = RandInt(n);
		lTextures += p;
		Place_Texture(PRIM_ECRAN, FACE_PRELOAD, p);
	}
	// Fonctionnement ordonné
	else {
		if(++iIndex > n) iIndex = 0;
		lTextures += iIndex;
		Place_Texture(PRIM_ECRAN, FACE_PRELOAD, iIndex);
	}
}

// -- Test de changement --
// @ return [integer] Test positif
integer Test_Request() {
	// Pas de demande de changement
	if(iRequest == CHANGE_NULL) {
		// Mode random
		if(iRandomShow) {
			Create_Random();
			return TRUE;}
		return FALSE;}
	// Demande de changement
	else if(iRequest == CHANGE_FUSION) Go(MODE_FUSION_SHOW, TRUE);
	else if(iRequest == CHANGE_DARK) Go(MODE_DARK_SHOW, TRUE);
	else if(iRequest == CHANGE_SWAPH) Go(MODE_SWAPH_SHOW, TRUE);
	else if(iRequest == CHANGE_SWAPD) Go(MODE_SWAPD_SHOW, TRUE);
	else if(iRequest == CHANGE_FAST) Go(MODE_FAST_SHOW, TRUE);
	else if(iRequest == CHANGE_CIRCLE) Go(MODE_CIRCLE_SHOW, TRUE);
	else if(iRequest == CHANGE_GROW) Go(MODE_GROW_SHOW, TRUE);
	else if(iRequest == CHANGE_OFF) Off();
	iRandomShow = FALSE;
	return TRUE;
}

// -- Génération de random mode --
Create_Random() {Go(RandIntBetween(MODE_FUSION_SHOW, MODE_GROW_SHOW), TRUE);}

// -- Test de mode --
// @ param [integer] Mode de fonctionnement
// @ return [integer] Test positif
integer Test_Mode(integer mode) {
	// Mode arrêt
	if(iMode == MODE_OFF) {
		Go(mode, TRUE);
		return FALSE;}
	// Mode Show
	else if(iMode > 99) {
		Go(mode, FALSE);
		return FALSE;}
	return TRUE;
}

// --  Arrêt --
Off() {
	iMode = MODE_OFF;
	// Arrêt du timer
	if(iEcouteMenu) llSetTimerEvent(TIMEOUT);
	else llSetTimerEvent(.0);
	// Message
	llWhisper(0, "mode is now Off");
}

//--------------------------------------------------------------------------------------
//                           VARIABLES GLOBALES
//--------------------------------------------------------------------------------------

//----------------------------------------------
//                  PARAMETRES
//----------------------------------------------
string		VERSION			= "1.4";
integer		PRIM_BASE		= 1;		// Numéro de la primitive de base
integer		PRIM_ECRAN		= 2;		// Numéro de la prim "écran"
integer		FACE_BASE		= 0;		// Numéro de la face de base
integer		FACE_ECRAN		= 0;		// Numéro de la face "écran"
integer		FACE_PRELOAD	= 5;		// Numéro de la face de pré-chargement

//----------------------------------------------
//                  MENUS
//----------------------------------------------
list 	MENU_MAIN 		= ["Exit","Settings"];
list	MENU_SETTINGS	= ["Back","Exit","Time Show","Time Trans"];
list 	MENU_TIME		= ["Back","Exit","2s","5s","10s","20s","30s","40s","50s","60s","120s","240s"];
list    ACCESS      	= ["Owner","Group","All"];

//----------------------------------------------
//                  VALEURS
//----------------------------------------------
integer		TYPE_MENU_MAIN 		= 0;
integer		TYPE_MENU_ACCESS	= 1;
integer		TYPE_MENU_SETTINGS	= 2;
integer		TYPE_MENU_TIMESHOW	= 3;
integer		TYPE_MENU_TIMETRANS	= 4;

integer		MODE_OFF			= 0;
integer		MODE_FUSION_TRANS	= 1;
integer		MODE_DARK_TRANS		= 2;
integer		MODE_SWAPH_TRANS	= 3;
integer		MODE_SWAPD_TRANS	= 4;
integer		MODE_CIRCLE_TRANS	= 5;
integer		MODE_GROW_TRANS	    = 6;
integer		MODE_RANDOM    	    = 7;

integer		MODE_FUSION_SHOW	= 100;
integer		MODE_DARK_SHOW		= 101;
integer		MODE_FAST_SHOW		= 102;
integer		MODE_SWAPH_SHOW		= 103;
integer		MODE_SWAPD_SHOW		= 104;
integer		MODE_CIRCLE_SHOW	= 105;
integer		MODE_GROW_SHOW	    = 106;

integer		CHANGE_NULL			= 0;
integer		CHANGE_OFF			= 1;
integer		CHANGE_FUSION		= 2;
integer		CHANGE_DARK			= 3;
integer		CHANGE_FAST			= 4;
integer		CHANGE_SWAPH		= 5;
integer		CHANGE_SWAPD		= 6;
integer		CHANGE_CIRCLE		= 7;
integer		CHANGE_GROW    		= 8;

//----------------------------------------------
//                  AUTRES
//----------------------------------------------
integer		iMode;					// Mode de fonctionnement
integer		iRandom;				// Mode Random
integer		iIndex;					// Index en mode ordonné
integer		iSens;					// Sens de modification pour mode Dark
integer		iRequest;				// Demande de changement
integer     iRandomShow;            // Mode Random de visualisation
string    	sAccess     = "Owner";	// Accès
float		fTimeShow	= 5.0;		// Durée de présence image
float		fTimeTrans	= 2.0;		// Durée de transition
float		fTempsBase	= .02;		// Temps de base
float		fPas;					// Pas de changement
float		fValeur;				// Valeur actuelle
vector      vEcran_size;            // Dimension de l'écran
vector      vEcran_pos;             // Position de l'écran;
list		lTextures;				// Liste des index des 3 textures

//--------------------------------------------------------------------------------------
//        STATE default
//--------------------------------------------------------------------------------------
default
{
	state_entry() {
		if(Build()) {
			// Message
			llWhisper(0, "Transition V"+ VERSION + " ready.");
			// Valeurs de départ pour swap
			list l = llGetLinkPrimitiveParams(PRIM_ECRAN, [PRIM_SIZE, PRIM_POSITION]);
			vEcran_size = llList2Vector(l, 0);
			vEcran_pos = Global2Local(llList2Vector(l, 1));
			// Initialisation
			Init();}
	}

	changed(integer change)	{
		if(change & CHANGED_INVENTORY) Init();
	}

	touch_start(integer total_number)
	{
		key k = llDetectedKey(0);
		if(TestAccess(k) == FALSE)
			llInstantMessage(k, "Sorry no access for you.");
		else {
			if(iBusy && k != kAvaMenu)
				llInstantMessage(k, "Sorry but the menu is busy.");
			else
				Menu_Main(k);
		}
	}

	listen(integer channel, string name, key id, string message) {
		// Test de changement de page pour navigation
		if(llListFindList([PREVIOUS,NEXT], [message]) != -1)
			GestIndexBoutons(message);
		// Reset du menu
		CancelMenu();
		// Sortie directe
		if(message == "Exit") return;
		else {
			// Gestion menu général
			if(iTypeMenu == TYPE_MENU_MAIN) {
				if(message == "Fusion") {
					if(Test_Mode(MODE_FUSION_SHOW))
						iRequest = CHANGE_FUSION;
					llWhisper(0, "mode is now Fusion");}
				else if(message == "Dark") {
					if(Test_Mode(MODE_DARK_SHOW))
						iRequest = CHANGE_DARK;
					llWhisper(0, "mode is now Dark");}
				else if(message == "Fast") {
					if(Test_Mode(MODE_FAST_SHOW))
						iRequest = CHANGE_FAST;
					llWhisper(0, "mode is now Fast");}
				else if(message == "Swap H") {
					if(Test_Mode(MODE_SWAPH_SHOW))
						iRequest = CHANGE_SWAPH;
					llWhisper(0, "mode is now Swap H");}
				else if(message == "Swap D") {
					if(Test_Mode(MODE_SWAPD_SHOW))
						iRequest = CHANGE_SWAPD;
					llWhisper(0, "mode is now Swap D");}
				else if(message == "Circle") {
					if(Test_Mode(MODE_CIRCLE_SHOW))
						iRequest = CHANGE_CIRCLE;
					llWhisper(0, "mode is now Circle");}
				else if(message == "Grow") {
					if(Test_Mode(MODE_GROW_SHOW))
						iRequest = CHANGE_GROW;
					llWhisper(0, "mode is now Grow");}
				else if(message == "Random") {
					iRandomShow = TRUE;
					if(iMode == MODE_OFF)Create_Random();
					llWhisper(0, "mode is now Random");}
				else if(message == "Off")
					iRequest = CHANGE_OFF;
				else if(message == "Settings")
					Menu_Settings(id);
			}
			// Gestion du menu Settings
			else if(iTypeMenu == TYPE_MENU_SETTINGS) {
				if(message == "Back")
					Menu_Main(id);
				else if(message == "Access")
					Menu_Access(id);
				else if(message == "Random") {
					iRandom = TRUE;
					Menu_Settings(id);}
				else if(message == "Order") {
					iRandom = FALSE;
					Menu_Settings(id);}
				else if(message == "Time Show")
					Menu_Time(id, fTimeShow, "\nSelect a time for show\n\nTime is now ",
					TYPE_MENU_TIMESHOW);
				else if(message == "Time Trans")
					Menu_Time(id, fTimeTrans, "\nSelect a time for transition\n\nTime is now ",
					TYPE_MENU_TIMETRANS);
			}
			// Gestion menu Access
			else if(iTypeMenu == TYPE_MENU_ACCESS) {
				if(message != "Back")
					sAccess = message;
				Menu_Settings(id);
			}
			// Gestion menus Time
			else {
				if(message != "Back") {
					if(iTypeMenu == TYPE_MENU_TIMESHOW)
						fTimeShow = (float)message;
					else if(iTypeMenu == TYPE_MENU_TIMETRANS)
						fTimeTrans = (float)message;}
				Menu_Settings(id);
			}
		}
	}

	timer()	{
		if(iEcouteMenu && llGetTime() > TIMEOUT) FinMenu();
		if(iMode == MODE_FUSION_SHOW) Init_Change(MODE_FUSION_TRANS);
		else if(iMode == MODE_DARK_SHOW) Init_Change(MODE_DARK_TRANS);
		else if(iMode == MODE_SWAPH_SHOW) Init_Change(MODE_SWAPH_TRANS);
		else if(iMode == MODE_SWAPD_SHOW) Init_Change(MODE_SWAPD_TRANS);
		else if(iMode == MODE_CIRCLE_SHOW) Init_Change(MODE_CIRCLE_TRANS);
		else if(iMode == MODE_GROW_SHOW) Init_Change(MODE_GROW_TRANS);
		else if(iMode == MODE_FAST_SHOW || iMode == MODE_FUSION_TRANS
			|| iMode == MODE_DARK_TRANS || iMode == MODE_SWAPH_TRANS
			|| iMode == MODE_CIRCLE_TRANS || iMode == MODE_GROW_TRANS
			|| iMode == MODE_SWAPD_TRANS) Change();
	}
}