/************************************************************************************
@ Author : Nicolas Castelli
@ Mail : nicolas.castelli2@gmail.com
@ Date of creation : 2008-01-01
@ Filename : MyWorkbook.js
@ Use : Javascript dédié aux classeurs des applications
************************************************************************************/

/************************************************************************/
/***********************  |WORKBOOK VSDECKMAKER|  *************************/
/************************************************************************/
MyWorkbook_VSDeckMaker = function() {
	//**** VARIABLES PRIVÉES
	var id = "";
	//Nombre de lignes de cartes dans le classeur
	var rowByPage = 2;
	//Nombre de cartes affichées par page du classeur
	var cardByRow = 7;
	//Indice de la première carte de la page
	var firstCardIndex = 0;
	var pool = new Array();
	var htmlCard = "";
	var transferMenu = "";
	//Composants HTML spécifiques
	//**** VARIABLES PUBLIQUES


	//**** FONCTIONS PRIVÉES
	//Initialisation des cartes et de leurs fonctions.
	//Si noclick = true, on rend les cartes non-cliquables
	var initCards = function(noclick) {

		var cardId = "";
		var rowI = 0;
		var cpt = 0;
		for(var i=0; i < cardByRow*2; i++)
		{
			//On change de ligne dès qu'on a traité la moitié des cartes
			if( cpt == cardByRow)
			{
				cpt = 0;
				rowI++;
			}
			cardId = id + "Card" + rowI + "_" + cpt;
			setCard(cardId, "images/structure/framgold.png", "framgold.png", "framgold.png", "cardHidden", true);
			cpt++;
		}
	}

	//Pour changer la source d'une image du classeur et ses différents attributs
	var setCard = function(cardId, cardSrc, cardAlt, cardTitle, cardClass, noclick, cardIndex) {
		var img = new MyImage()
		if(localVersion == 1)
			$(cardId).src = "http://www.google.fr/" + cardTitle; //VERSION LOCALE
		else
		{
			$(cardId).src = cardSrc; //VERSION NORMALE
			// Préchargement du grand format de la carte
			img.preload(cardSrc);
		}
		$(cardId).alt = cardAlt;
		$(cardId).title = cardTitle.replace(/&apos;/gi, "'");
		$(cardId).className = cardClass;

		//Fonctions
		$(cardId).onmouseover = function() { mouseOverCard(this.id); } ;
		//On Click : on affiche le menu pour supprimer des cartes
		if(noclick == true)
			$(cardId).onclick = function() { return false; } ;
		else
		{
			//Spécificité pour IE
			if (globalBrowser.getNavigator() == "Internet Explorer" )
				$(cardId).onclick = function() { mouseClickCard(event, cardIndex); };
			else
				$(cardId).onclick = function(event) { mouseClickCard(event, cardIndex) ; };
		}
	}

	//Si noclick = true, on rend les cartes non-cliquables
	var initPool = function(noclick) {
		var cardId = "";
		var rowI = 0;
		var cpt = 0;
		var cardName = "";
		var cardSrc = "";
		var cardSrcId = "";
		//On affiche le nombre de cartes trouvés
		displayCardsNumber();
		//On affiche le nombre de cartes trouvés
		for(var i=0; i < cardByRow*2; i++)
		{
			var card = pool[i + firstCardIndex];
			//On change de ligne dès qu'on a traité la moitié des cartes
			if( cpt == cardByRow )
			{
				cpt = 0;
				rowI++;
			}
			cardId = id + "Card" + rowI + "_" + cpt;
			if(card)
			{
				//Modification des images du classeur
				//Gestion des versions localisées
				if(card.nom_lang)
				{
					cardName = card.nom_lang;
					cardSrc = card.srcscan_lang;
					cardSrcId = card.nomscan_lang;
				}
				else
				{
					cardName = card.nom;
					cardSrc = card.srcscan;
					cardSrcId = card.nomscan;
				}
				setCard(cardId, cardSrc + cardSrcId, cardSrcId, cardName, "cardShowed", false, i + firstCardIndex);
			}
			cpt++;
		}
	}

	//Affiche le nombre de cartes du pool du classeur
	var displayCardsNumber = function() {
		if (pool)
			$(id + "CardsNumber").innerHTML = pool.length;
		else
			$(id + "CardsNumber").innerHTML = 0;
	}

	/**********  GESTION DES PAGES DU CLASSEUR  **********/
	//Pour "tourner" les différentes pages du classeur
	var changePage = function(way) {
		var start = 0;
		//A droite
		if (way == "next")
			start = firstCardIndex + (cardByRow*2) ;
		//A gauche
		else if (way == "prev")
			start = firstCardIndex - (cardByRow*2) ;
		//On corrige les positions de départ incohérentes
		//Si la position de départ dépasse la taille du tableau, ou bien qu'elle est inférieure à 0,
		//on ne peut pas changer de page.
		if (!( (start < 0) || (start > pool.length) ))
		{
			firstCardIndex = start;
			//On vide la page du classeur à chaque changement de pages
			initCards();
			//On met à jour le classeur
			//Pour résoudre un bug Opéra, qui est trop rapide, je suis obligé de mettre un  timeout..
			if(globalBrowser.getNavigator() == "Opera")
				setTimeout( function(){ initPool(); }, 1500);
			else
				initPool();
			//On met à jour les flèches
			updateArrows();
		}
	}

	//Desactive une flèche
	var disableArrow = function(arrowId) 	{
		$(arrowId).className = "off";
		$(arrowId).onclick = function(){ return false; } ;
		$(arrowId).onmouseover = function(){ return false; } ;
		$(arrowId).onmouseout = function(){ return false; } ;
	}

	//Active une flèche
	var activeArrow = function(arrowId, way) 	{
		$(arrowId).className = "on";
		$(arrowId).onclick = function(){ changePage(way); } ;
		$(arrowId).onmouseover = function(){ this.className = "hover"; } ;
		$(arrowId).onmouseout = function(){ this.className = "on"; } ;
	}

	//Contrôle le status des flèches pour changer de page
	//Si on commence de 0, on ne peut pas aller vers la gauche
	//Si on commence de 0 et que le nombre de cartes trouvées est inférieure au nombre
	//de cartes affichables, on ne peut pas aller vers la droite.
	//De même si on démarre de la même position que celle du workbook.
	var updateArrows = function () 	{
		activeArrow(id + "PrevArrow", "prev");
		activeArrow(id + "NextArrow", "next");
		if (firstCardIndex == 0)
			disableArrow(id + "PrevArrow");
		if( (firstCardIndex + cardByRow) >= pool.length )
			disableArrow(id + "NextArrow");
	}

	/**********  GESTION DES EVENEMENTS SUR LES CARTES DU DECK  **********/
	//Quand on survole avec la souris une des cartes du classeur  :
	//1) On affiche le grand scan
	//2) On met à jour le texte sous la carte
	var mouseOverCard = function(id) {
		var indexArray = id.substr(id.length - 3, id.length).split("_");
		var index = 0;
		if( parseInt(indexArray[0]) == 0 )
			index = firstCardIndex + parseInt(indexArray[1]);
		else
			index = firstCardIndex + cardByRow  + parseInt(indexArray[1]);

		var card = pool[index];

		if (card)
		{
			if(localVersion == 1)
			{
			//VERSION LOCALE
			htmlCard.updateText(card);
			}
			else
			{
				//VERSION NORMALE
				htmlCard.updateScan(card);
				htmlCard.updateText(card);
			}
		}
	}

	//Gestion du clic gauche sur une carte du classeur
	var mouseClickCard = function(evt, cardIndex) {
		var cardToTrf = pool[cardIndex];
		var transfertCards = new Array(Array(cardToTrf, 0));
		transferMenu.prepareTransfert(evt, transfertCards, 1);
	}


	//**** FONCTIONS PUBLIQUES
	this.construct = function(iftId, refCard, trsfMenu) {
		id = iftId;
		pool = new Array();
		htmlCard = refCard;
		transferMenu = trsfMenu;
	}

	this.updateInterface = function(newPool) {
		pool = newPool.slice();
		//On vide la page du classeur à chaque chargement
		//On réinitialise le n° de premiere carte à 0.
		firstCardIndex = 0;
		initCards();
		initPool(true);
		updateArrows();
	}




}//Fin de la classe MyWorkbook_VSCreator




/************************************************************************/
/***********************  |WORKBOOK VSCREATOR|  *************************/
/************************************************************************/
MyWorkbook_VSCreator = function() {
	//**** VARIABLES PRIVÉES
	var id = "";
	var cardByRow = 4;
	var pool = new Array();
	//Composants HTML spécifiques
	//Boutons
	var compBt_Mode = "BT_VSMODE";
	var compBt_OrderName = "BT_ORDERBYNAME";
	var compBt_OrderCost = "BT_ORDERBYCOST";
	var compBt_OrderType = "BT_ORDERBYTYPE";
	var compBt_OrderPow = "BT_ORDERBYPOW";
	var compBt_OrderTgh = "BT_ORDERBYTGH";
	var compBt_OrderRarity = "BT_ORDERBYRARITY";
	//Pour le survol des cartes
	var floatCardId = "floatCard";
	var floatScanId = "floatScan";
	var floatCard = new MyFloatCard();
	//Pour le tri de cartes
	var sortActions = new Array(0, 0, 0, 0, 0, 0);

	//**** VARIABLES PUBLIQUES


	//**** FONCTIONS PRIVÉES
	//Passe de l'affichage visuel à l'affichage texte et vice-versa
	var switchWorkbookMode = function()
	{
		var arrLbl = $(compBt_Mode).name.split(";");
		//On passe en mode visuel
		if($(compBt_Mode).innerHTML == arrLbl[0])
		{
			$(compBt_Mode).innerHTML = arrLbl[1];
			$(id+"Scan").className = "none";
			$(id+"Text").className = "";
		}
		//On passe en mode texte
		else
		{
			$(compBt_Mode).innerHTML = arrLbl[0];
			$(id+"Text").className = "none";
			$(id+"Scan").className = "";
		}
	}

	//Charge la partie "Scans" du classeur
	var loadWorkbookWithScans = function() {
		var size = pool.length;
		var i = 0;
		var rowCpt = 0;
		var imgRow = $(id+"TableScan").insertRow(-1);
		//On affiche la taille du pool
		displayCardsNumber();
		//On affiche les cartes du pool
		for(i = 0; i < size; i++)
		{
			var card = pool[i];
			//Si on a déjà ajouté cardByRow cellules, on ajoute une nouvelle ligne
			if(rowCpt == cardByRow)
			{
				imgRow = $(id+"TableScan").insertRow(-1);
				rowCpt = 0;
			}
			var newCell = imgRow.insertCell(rowCpt);
			var newImg = new Image();
			newImg.id = "workbookCard" + i;
			//Gestion des versions localisées
			if(card.nom_lang)
			{
				if(localVersion == 1)
				{
					newImg.src = "http://www.google.fr/" + card.nomscan_lang; //VERSION LOCALE
				}
				else
				{
					newImg.src = card.srcscan_lang + card.nomscan_lang; //VERSION NORMALE
				}
				newImg.alt = card.nom_lang.replace(/&apos;/gi, "'");
			}
			else
			{
				if(localVersion == 1)
				{
					newImg.src = "http://www.google.fr/" + card.nomscan; //VERSION LOCALE
				}
				else
				{
					newImg.src = card.srcscan + card.nomscan; //VERSION NORMALE
				}

				newImg.alt = card.nom.replace(/&apos;/gi, "'");
			}
			newImg.className = "cardShowed";
			//Spécificité pour IE
			if (globalBrowser.getNavigator() == "Internet Explorer" )
			{
				newImg.onclick = function() {
					var index = parseInt(this.id.split("workbookCard")[1]);
					var card = pool[index];
					floatCard.showFloatCard(event, card);
				};
			}
			else
			{
				newImg.onclick = function(event) {
					var index = parseInt(this.id.split("workbookCard")[1]);
					var card = pool[index];
					floatCard.showFloatCard(event, card);
				};
			}

			newImg.onmouseout = function() { floatCard.close(); };
			newCell.appendChild(newImg);
			rowCpt++;
		}
	}

	//Charge la partie "Texte" du classeur
	var loadWorkbookWithText = function() {
		var size = pool.length;
		var i = 0;
		var altern = 0;
		//On affiche la taille du pool
		displayCardsNumber();
		for(i = 0; i < size; i++)
		{
			var card = pool[i];
			var textRow = $(id+"TableText").insertRow(-1);
			textRow.id = id+"TableTextRow"+i;
			if(altern == 0)
			{
				textRow.className = "rowBlack";
				altern = 1;
			}
			else
			{
				textRow.className = "rowWhite";
				altern = 0;
			}
			//Quand on survole une ligne, la carte apparaît
			textRow.onmouseover = function() { floatCard.showFloatScan(this.id); }
			textRow.onmouseout = function() { floatCard.hideScan(); }
			addTextRow(textRow, card);
		}
	}

	//Ajoute une carte au format texte, dans une ligne de tableau
	var addTextRow = function(row, card) {
		var textCell = row.insertCell(0);
		var rarete = card.rarete;
		//Gestion des versions localisées
		if(card.nom_lang)
		{
			var rarete_lang = card.rarete_lang;
			textCell.innerHTML = card.nom_lang.replace(/&apos;/gi, "'");;
			textCell.className = "nom";
			textCell = row.insertCell(1);
			textCell.innerHTML = card.couleur;
			textCell.className = "couleur";
			textCell = row.insertCell(2);
			textCell.innerHTML = card.couthtml;
			textCell.className = "cout";
			textCell = row.insertCell(3);
			textCell.innerHTML = card.type_lang;
			if(card.soustype_lang != " " && card.soustype_lang != "")
				textCell.innerHTML += " - " + card.soustype_lang;
			textCell.className = "type";
			textCell = row.insertCell(4);
			textCell.innerHTML = card.force;
			textCell.className = "couleur";
			textCell = row.insertCell(5);
			textCell.innerHTML = card.endurance;
			textCell.className = "couleur";
			textCell = row.insertCell(6);
			textCell.innerHTML = card.ruleshtml_lang.replace(/&apos;/gi, "'");;
			textCell.className = "rules";
			textCell = row.insertCell(7);
			//On convertit les raretes spéciales
			if(card.rarete_lang == "BasicLand") {rarete_lang = "Common";}
			else if(card.rarete_lang == "MythicRare") {rarete_lang = "Mythic Rare";}
			textCell.innerHTML = rarete_lang;
			textCell.className = "rarete";
			//On ajoute l'image à afficher quand on survole, mais cachée sinon.
			textCell = row.insertCell(8);
			textCell.style.display = "none";
			textCell.innerHTML = card.srcscan_lang + card.nomscan_lang;
		}
		else
		{
			var rarete = card.rarete;
			textCell.innerHTML = card.nom.replace(/&apos;/gi, "'");;
			textCell.className = "nom";
			textCell = row.insertCell(1);
			textCell.innerHTML = card.couleur;
			textCell.className = "couleur";
			textCell = row.insertCell(2);
			textCell.innerHTML = card.couthtml;
			textCell.className = "cout";
			textCell = row.insertCell(3);
			textCell.innerHTML = card.type;
			if(card.soustype != " " && card.soustype != "")
				textCell.innerHTML += " - " + card.soustype;
			textCell.className = "type";
			textCell = row.insertCell(4);
			textCell.innerHTML = card.force;
			textCell.className = "couleur";
			textCell = row.insertCell(5);
			textCell.innerHTML = card.endurance;
			textCell.className = "couleur";
			textCell = row.insertCell(6);
			textCell.innerHTML = card.ruleshtml.replace(/&apos;/gi, "'");;
			textCell.className = "rules";
			textCell = row.insertCell(7);
			//On convertit les raretes spéciales
			if(card.rarete == "BasicLand") {rarete = "Common";}
			else if(card.rarete == "MythicRare") {rarete = "Mythic Rare";}
			textCell.innerHTML = rarete;
			textCell.className = "rarete";
			//On ajoute l'image à afficher quand on survole, mais cachée sinon.
			textCell = row.insertCell(8);
			textCell.style.display = "none";
			textCell.innerHTML = card.srcscan + card.nomscan;
		}
	}

	//Affiche le nombre de cartes du pool du classeur
	var displayCardsNumber = function() {
		if (pool)
			$(id + "Number").innerHTML = pool.length;
		else
			$(id + "Number").innerHTML = 0;
	}

	//Pour vider le classeur (suppression des lignes)
	var emptyWkbk = function(idTable){
		var arrRows = $(idTable).rows;
		var start = arrRows.length-1;
		for(var i=start; i >= 0; i--)
		{
			$(idTable).deleteRow(i);
		}
	}

	//***************** TRI DES CARTES *****************//
	//Pour ordonner les cartes du spoiler texte
	var sortTextSpoiler = function(sortMethod) {
		//1)D'ABORD ON VIDE LE TEXTE SPOILER
		emptyWkbk(id+"TableText");
		//2)ENSUITE ON MODIFIE L'ORDRE DE RANGEMENT DU POOL DE BASE
    determinePoolOrder(sortMethod);
		loadWorkbookWithText();
	}

	//Le pool de cartes est trié par ordre alphabétique
	var determinePoolOrder = function(method) {
		var sToSort = "";
		var sFinalToSort = "";
		var arrTmp = new Array();
		var raritySort = new Array("MythicRare", "Rare", "Uncommon", "Common");
		var aPreSort = new Array();
		var vDim = "";
		var vDimVal = ""
		for(var i = 0; i < pool.length; i++)
		{
			var card = pool[i];
			vDim = "";
			vDimVal = card.nom + "#" + i;
			if(method == "NAME")
			{
				if(card.nom_lang)
				{
					vDim = card.nom_lang;
					vDimVal = card.nom_lang + "#" + i;
				}
				else
					vDim = card.nom;

			}
			else if(method == "TYPE")
				vDim = card.type + "_" + card.soustype;
			else if(method == "COST")
			{
				if(parseInt(card.valeurcout) < 10)
					vDim = "0" + card.valeurcout + "_" + card.cout;
				else
					vDim = card.valeurcout + "_" + card.cout;
			}
			else if(method == "POW")
				vDim = card.force;
			else if(method == "TGH")
				vDim = card.endurance;
			else if(method == "RARITY")
				vDim = card.rarete;

			//Un tableau où, pour chaque valeur de la dimension donnée,
			//on a la liste des noms de cartes associés
			if(!aPreSort[vDim])
				aPreSort[vDim] = new Array();
			aPreSort[vDim].push(vDimVal);
			//Les cartes doivent rester triées par ordre alpha
			aPreSort[vDim].sort();
		}

		if(method == "RARITY")
			sortPool(aPreSort, method, raritySort);
		else
			sortPool(aPreSort, method);
	}

	//Classe le tableau
	var sortPool = function(aCards, method, aOrder) {
		var vKey = "";
		var vIndex = 0;
		var orderPool = new Array();
		//Si un ordre de classement est défini, on l'utilise
		//Sinon, il s'agit simplement de l'ordre croissant
		if(!aOrder)
		{
			var aOrder = new Array();
			for(k in aCards)
			{
				aOrder.push(k);
			}
			aOrder.sort();
		}
		//On classe le pool
		for(var i = 0; i < aOrder.length; i++)
		{
			vKey = aOrder[i];
			if(aCards[vKey] != null)
			{
				for(var j = 0; j < aCards[vKey].length; j++)
				{
					//La valeur récupérée est : card.nom + "#" + i
					vIndex = parseInt(aCards[vKey][j].split("#")[1]);
					orderPool.push(pool[vIndex]);
				}
			}
		}
		//Affectation finale
		pool.length = 0;
		pool = orderPool.slice();
		orderPool.length = 0;
		if( (method == "NAME" && sortActions[0] == 0) ||
				(method == "TYPE" && sortActions[1] == 0) ||
				(method == "COST" && sortActions[2] == 0) ||
				(method == "POW" && sortActions[3] == 0) ||
				(method == "TGH" && sortActions[4] == 0) ||
				(method == "RARITY" && sortActions[5] == 0)
		  )
		{
			invertArray(pool);
		}

	}

	//On enregistre le type de classement effectué
	var updSortActions = function(vIndex) {
		var vVal = sortActions[vIndex];
		if(vVal == 0)
			sortActions[vIndex] = 1;
		else
			sortActions[vIndex] = 0;
	}

	//**** FONCTIONS PUBLIQUES
	this.construct = function(iftId) {
		id = iftId;
		pool = new Array();
		floatCard.construct(floatCardId, floatScanId);
		$(compBt_Mode).onclick = function() { switchWorkbookMode(); };
		if($(compBt_OrderName))
			$(compBt_OrderName).onclick = function() { updSortActions(0); sortTextSpoiler("NAME"); };
		if($(compBt_OrderType))
			$(compBt_OrderType).onclick = function() { updSortActions(1); sortTextSpoiler("TYPE"); };
		if($(compBt_OrderCost))
			$(compBt_OrderCost).onclick = function() { updSortActions(2); sortTextSpoiler("COST"); };
		if($(compBt_OrderPow))
			$(compBt_OrderPow).onclick = function() { updSortActions(3); sortTextSpoiler("POW"); };
		if($(compBt_OrderTgh))
			$(compBt_OrderTgh).onclick = function() { updSortActions(4); sortTextSpoiler("TGH"); };
		if($(compBt_OrderRarity))
			$(compBt_OrderRarity).onclick = function() { updSortActions(5); sortTextSpoiler("RARITY"); };

	}

	this.updateInterface = function(newPool) {
		pool = newPool.slice();
		//1) On vide le classeur
	 	emptyWkbk(id+"TableScan");
	 	emptyWkbk(id+"TableText");
	 	//2) On remplit le classeur
		loadWorkbookWithScans();
		loadWorkbookWithText();
	}




}//Fin de la classe MyWorkbook_VSCreator


/************************************************************************/
/****************************  |WORKBOOK |  *****************************/
/************************************************************************/
//Classe pour le classeur
MyWorkbook = function() {
	//**** VARIABLES PRIVÉES
	//Valeur du filtre
	var fltVal = "";
	//Base de données
	var pool = new Array();
	//Base de données après application du filtre
	var fltPool = new Array();
	//Filtre associé
	var filter = "";
	//Interface graphique du classeur
	var interface = "";

	//**** VARIABLES PUBLIQUES


	//**** FONCTIONS PRIVÉES

	//------------------- INTERACTION INTERFACE WORKBOOK ----------------------//


	//-------------------------- CHARGEMENT DU BLOC --------------------------//
	//Le changement de bloc entraine le chargement d'un nouveau fichier JSON
	//et d'une réinitialisation de l'application
	var updateBlock = function(fileName) {
		var allCards = new Array();
		//Lors de l'initialisation, le pool filtré est égal au pool de base
		allCards = globalBrowser.getJSONData(fileName, false);
		//Si le fichier chargé n'est pas vide, on charge les cartes
		if(allCards.length != 0 && allCards.cartes.carte)
		{
			var JSONPool = allCards.cartes.carte;
			pool = JSONPool.slice();
			fltPool = JSONPool.slice();
		}
		//Puis on charge le classeur avec les cartes
		interface.updateInterface(fltPool);
		//A la fin du chargement, on cache la div de chargement
		loadingBar.hide();
	}

	//-------------------------- INTERACTION FILTRE --------------------------//
		//On parcourt le pool de cartes (fichier chargé) et on sélectionne celles qui
	//doivent être affichés en fonction des critères du filtre.
	var findFltPool = function() {
		//On vide le pool filtré
		fltPool.length = 0;
		//On détermine le nouveau pool filtré en fonction des paramètres du filtre.
		for(var i=0; i < pool.length; i++)
		{
			var card = pool[i];
			//On verifie les cartes	et on ajoute uniquement celles qui correspondent
			//au filtre
			if(checkCard(card))
				fltPool.push(card);
		}
		//Une fois le nouveau pool chargé, on réinitialise le classeur
		//reset();
	}


	//On vérifie une carte par rapport aux critères du filtre
	var checkCard = function(card) {
		var tParams = fltVal.split("#");
		var fltColor = getFltColor(tParams[2]);
		var fltColorMode = tParams[3];
		var fltType = tParams[4];
		var fltRarity = tParams[5];
		var fltCC_O = tParams[6];
		var fltCC_V = tParams[7];
		var fltPow_O = tParams[8];
		var fltPow_V = tParams[9];
		var fltTgh_O = tParams[10];
		var fltTgh_V = tParams[11];
		var fltSearch = tParams[12];
		var isColorless = false; //Faut-il faire un test sur la couleur ? (pour cas carte incolore)
		var isOK = false;
		var cardForce = 0;
		var cardEndurance = 0;
    //Cas des enchantements, terrains, ephemeres, et autres, qui n'ont pas de force ni d'endurance...
    if(card.force && card.force !="" && card.force !=" ") {cardForce = card.force;}
    if(card.endurance && card.endurance !="" && card.endurance !=" " ) {cardEndurance = card.endurance;}

		//Le filtrage est actif sur les cartes incolores ?
		if(fltColor.hasChar("C"))
		{
			if(checkIsColorless(card.cout))
				isColorless = true;
			else //Test normal sur les couleurs
				fltColor = fltColor.replace("C", "");		}
		//Sinon, est-il inactif avec cependant un colorMode actif ???
		else if( !isActive(fltColor) && isActive(fltColorMode) )
		{
			//Si aucune couleur n'est choisie, on affiche toutes les cartes multicolores ou hybrides
			if(fltColorMode.charAt(0) == "H" && ( checkIsHybrid(card.cout, "W") || checkIsHybrid(card.cout, "R") ||
			   checkIsHybrid(card.cout, "G") || checkIsHybrid(card.cout, "U") || checkIsHybrid(card.cout, "B") ) )
			{
				isColorless = true;
			}
			else if(fltColorMode.charAt(0) == "G" && (checkIsGold(card.cout, "W") || checkIsGold(card.cout, "R") ||
			   checkIsGold(card.cout, "G") || checkIsGold(card.cout, "U") || checkIsGold(card.cout, "B") ) )
			{
				isColorless = true;
			}
		}

		/*
		if( ((isActive(fltColor) && checkColor(card.cout, fltColor, fltColorMode)) || isColorless) )
			alert(card.nom + " Color =" + true);
		if( (isActive(fltType) && checkType(card.type, fltType)) )
			alert(card.nom + " Type =" + true);
		if( (isActive(fltRarity) && checkRarity(card.rarete, fltRarity)) )
			alert(card.nom + " Rare =" + true);
		if( (isActive(fltSearch) && (( card.nom_lang && checkSearch(card.nom_lang, card.type_lang + "-" + card.soustype_lang, card.ruleshtml_lang, fltSearch) ) || (checkSearch(card.nom, card.type + "-" + card.soustype, card.ruleshtml, fltSearch))) ) || !isActive(fltSearch) )
			alert(card.nom + " Text =" + true);
		alert(card.nom + " CC =" + checkCCPT(card.valeurcout, fltCC_O, fltCC_V));
		alert(card.nom + " Pow =" + checkCCPT(cardForce, fltPow_O, fltPow_V));
		alert(card.nom + " End =" + checkCCPT(cardEndurance, fltTgh_O, fltTgh_V));
		*/

		//Certains paramètres du filtre peuvent être inactifs, d'autres sont obligatoires
		if( ( (isActive(fltColor) && checkColor(card.cout, fltColor, fltColorMode)) || isColorless) &&
				( (isActive(fltType) && checkType(card.type, fltType))) &&
			 	( (isActive(fltRarity) && checkRarity(card.rarete, fltRarity))) &&
			 	( (isActive(fltSearch) && (( card.nom_lang && checkSearch(card.nom_lang, card.type_lang + "-" + card.soustype_lang, card.ruleshtml_lang, fltSearch) ) || (checkSearch(card.nom, card.type + "-" + card.soustype, card.ruleshtml, fltSearch))) ) || !isActive(fltSearch) ) &&
			 	(checkCCPT(card.valeurcout, fltCC_O, fltCC_V)) &&
			 	(checkCCPT(cardForce, fltPow_O, fltPow_V)) &&
			 	(checkCCPT(cardEndurance, fltTgh_O, fltTgh_V))
			)
		{
			isOK = true;
		}
		return isOK;
	}

	//Traitement spécifique du filtre sur les couleurs, pour retourner
	//la chaîne de filtre sur le cout au format attendu
	var getFltColor = function(param) {
		var fltColor =  param.split(";");
		var vVal = "";
		for(var i=0; i < fltColor.length; i++)
		{
			vVal += fltColor[i].charAt(0);
		}
		return vVal;
	}

	// Vérifie si un paramètre du filtre est actif.
	// Il l'est si sa longueur est > 1.
	var isActive =  function(param) {
		if(param.length > 0) {return true;} else {return false;}
	}

	//Pour vérifier qu'une carte est "gold" (ie multicolore)
	var checkIsGold = function(cardColor, fltColor) {
		var result = false;
		if(fltColor.length == 1)
		{
			var checkMulti = new Array("W", "R", "G", "U", "B");
			for(var i=0; i < checkMulti.length; i++)
			{
				if(fltColor != checkMulti[i])
				{
					result = cardColor.hasAllChar(fltColor+checkMulti[i]);
					if(result) { break; }
				}
			}
		}
		else
			result = cardColor.hasAllChar(fltColor);
		return result;
	}

	//Pour vérifier qu'une carte est "hybride" : à noter qu'une carte
	//hybride est toujours "gold", mais que le contraire n'est pas vrai
	var checkIsHybrid = function(cardColor, fltColor) { return cardColor.hasAllChar(fltColor+"("); }

	//Pour vérifier si la couleur de la carte correspond bien à celle du filtre
	var checkColor = function(cardColor, fltColor, fltColorMode) {
		//Selon le mode, le fonctionnement change
		switch(fltColorMode.charAt(0))
		{
			//hybride, c'est une carte qui contient un coût de style (x/x)
			//Si aucune couleur n'est choisie, on affiche toutes les cartes hybrides
			case "H" :
				return checkIsHybrid(cardColor, fltColor);
			break;
			//gold (=multicolor), c'est une carte qui contient plusieurs couleurs dans son coût.
			//Si aucune couleur n'est choisie, on affiche toutes les cartes multicolores
			case "G" :
				return checkIsGold(cardColor, fltColor);
			break;
			default:
				return cardColor.hasChar(fltColor);
			break;
		}
	}

	//Pour vérifier qu'une carte est un artefact ou non
	var checkIsColorless = function(cardColor) {
		var colorTest = cardColor.replace(/X/g, "");
		//Si c'est un nombre, c'est OK
		if(!isNaN(colorTest))
			return true;
		else
			return false;
	}

	//Pour vérifier si le type de la carte correspond bien à celui du filtre
	var checkType = function(cardType, type) {
		return cardType.toUpperCase().hasWords(type);
	}

	//Pour vérifier si la rareté de la carte correspond bien à celle du filtre
	var checkRarity = function(cardRarity, rarity) {
		//1)Les terrains basiques ont pour rareté "BasicLand". Comme j'ai choisi
		//de garder cette rareté spécifique en base, je la transforme ici en "Common" pour
		//que le filtre sur la rareté ne supprime pas les terrains de base.
		//2)Même problème avec les cartes TimeShifted, je vais mettre comme des "Rares"
		if(cardRarity == "BasicLand")
			cardRarity = "Common";
		else if(cardRarity == "Special")
			cardRarity = "Rare";
		return cardRarity.toUpperCase().hasWords(rarity, 0, 1);
	}

  //Pour vérifier si le coût converti de la carte correspond bien à celui du filtre
  //Fonctionne aussi pour la force et l'endurance.
	var checkCCPT = function(cardCCPT, ccptSig, ccptVal) { return doComparison(cardCCPT, ccptSig, ccptVal);	}

	//Pour vérifier si le texte de la carte correspond bien à celui du filtre
	//On vérifie le texte, le nom et le type de la carte, selon les contraintes suivantes :
	//- 1) la recherche textuelle doit contenir des mots de plus de 3 lettres
	//- 2) le seul caractère spécial admis est le ";"
	var checkSearch = function(cardName, cardType, cardRules, search) {
		//Chaine de recherche validée
		var goodSearch = "";
		var isOK = false;
		var toTest = false;
		var i=0;
		//On convertit les '
		search = search.replace("'", "&apos;");
		if(search.length > 3 && !search.hasChar(";"))
			toTest = true;
		else if(search.length > 3 && search.hasChar(";"))
		{
			var arr = search.split(";");
	 		for(i=0; i < arr.length; i++)
			{
				var word = arr[i];
				//On reconstitue une chaine de recherche valide à partir des mots saisis
				if(word.length > 3)
					goodSearch += word + ";";
			}
			//On supprime le dernier caractère qui est un ";" inutile
			goodSearch = goodSearch.substr(0, goodSearch.length - 1);
			if(goodSearch.length > 3)
			{
				search = goodSearch;
				toTest = true;
			}
		}
		//On teste la chaine
		if(toTest && ( cardName.hasWords(search) || cardType.hasWords(search) || cardRules.hasWords(search) ) )
    	isOK = true;
    return isOK;
	}


	//**** FONCTIONS PUBLIQUES
	//Constructeur de classe
	this.construct = function(wbkInterface, wbkFilter) {
		pool = new Array();
		//Base de données après application du filtre
		fltPool = new Array();
		interface = wbkInterface;
		filter = wbkFilter;
	}

	//Quand on change de set ou de langue de set, un nouveau fichier est chargé
	this.loadSet = function(filterValue) {
		var tParams = filterValue.split("#");
		var setInit = tParams[0];
		var setLang = tParams[1];
		var setPath = "";
		if(setInit != "" && setInit.length > 1 && setInit != " ")
		{
			setPath = "editions/" + setLang + "/" + setInit + "_" + setLang + ".json";
			if(setLang == "EN")
				setPath = "editions/" + setInit + ".json";
			//On réinitialise le filtre
			filter.resetFlt();
			//On affiche la barre de chargement
			loadingBar.show();
			//On charge le fichier
			setTimeout( function(){ updateBlock(setPath); }, 1500);
		}
	}

	//Quand on change l'un des paramètres du filtre, il faut mettre
	//à jour ce qui est affiché dans le workbook.
	this.updateWbk = function(filterValue) {
		fltVal = filterValue;
		findFltPool();
		interface.updateInterface(fltPool);
	}

} //Fin de la classe MyWorkbook