// ------------------------------------------------------------------------
// Script jsfl - 'choppeCodeFiltre' - v 1.0

// Commande créé par Ronan (_molecule_) le 13.04.2006
// ronan.z@free.fr - http://teknicolor.free.fr

// Permets de récupérer le code ActionScript d'un filtre appliqué à un objet de la scène.
// Pourquoi ?
// Cela permets d'effectuer ses tests de filtres sur un movieClip ou textField pour voir rapidement le résultat.
// On lance cette commande et on copie-colle le résultat pour pouvoir appliquer dynamiquement ce(s) filtres(s) en ActionScript
// Penser à supprimer les filtres appliqués dans Flash au movieClip ou textField aprés.

// Remarques :
// Ce script permets de récuper le code pour plusieurs filtres appliqués à un movieClip ou textField.
// !! ne fonctionne pas pour le filtre 'adjustColorFilter'

// L'aide pour le jsfl dans la doc Flash 8 : 'Extension de Flash -> Objets'
// Ce script .jsfl est à copier à cet endroit : 
// C:\Documents and Settings\ronan\Local Settings\Application Data\Macromedia\Flash 8\fr\Configuration\Commands
// ------------------------------------------------------------------------

// On obtient ce type de résultat dans la fenêtre de sortie :

// ---- Paramètres Flash du filtre DropShadowFilter ----
// name: dropShadowFilter [string]
// angle: 44.999998781459 [number]
// blurX: 5 [number]
// blurY: 5 [number]
// distance: 5 [number]
// color: '#ffcc0099' [string]
// quality: low [string]
// strength: 100 [number]
// inner: false [boolean]
// knockout: false [boolean]
// hideObject: false [boolean]
//
//
// ---- Code AS du filtre --- 
// import flash.filters.DropShadowFilter
// var fiDropShadowFilter:DropShadowFilter = new DropShadowFilter(5, 44.999998781459, 0xFFCC00, 0.6, 5, 5, 1, 1, false, false, false)
// var aFilters:Array = new Array()
// aFilters.push(fiDropShadowFilter)
// tfdropShadowFilter.filters = aFilters
// // DropShadowFilter([distance:Number], [angle:Number], [color:Number], [alpha:Number], [blurX:Number], [blurY:Number], [strength:Number], [quality:Number], [inner:Boolean], [knockout:Boolean], [hideObject:Boolean])


fl.outputPanel.clear()
this.choppeCodeFiltre()

function choppeCodeFiltre() {
	
	var oCurrentDoc = fl.getDocumentDOM()
	var nNbElements = oCurrentDoc.selection.length
	
	if (nNbElements==0) {
		fl.trace("!! choppeCodeFiltre : Aucun élément sélectionné !!")
		return;
	}	
	
	var sNomOccurence = oCurrentDoc.selection[0].name	
	if (sNomOccurence=="") { sNomOccurence = "mcCible" }
	
	var aFilter = document.getFilters()	
	var nNbFiltres = aFilter.length	
	
	var sCodeHelpFinal = ""
	var sCodeDeb = ""
	var sCodeFiltre = ""
	var sCodePush = ""
	
	for (var f = 0; f < nNbFiltres; f++) {	
	
		var oFilter = aFilter[f]		
		var sNomFiltre = oFilter["name"]
		
		var aProp = []
		var sCodeHelp = ""
		
		switch (sNomFiltre) {
			case "dropShadowFilter": // ombre portée			
				aProp = ["distance","angle","color","alpha","blurX","blurY","strength","quality","inner","knockout","hideObject"]
				sCodeHelp = "// DropShadowFilter([distance:Number], [angle:Number], [color:Number], [alpha:Number], [blurX:Number], [blurY:Number], [strength:Number], [quality:Number], [inner:Boolean], [knockout:Boolean], [hideObject:Boolean])"
				break
			case "blurFilter": // flou			
				aProp = ["blurX","blurY","quality"] // quality = low
				sCodeHelp = "// BlurFilter([blurX:Number], [blurY:Number], [quality:Number])"
				break
			case "glowFilter": // rayonnement			
				aProp = ["color","alpha","blurX","blurY","strength","quality","inner","knockout"]
				sCodeHelp = " //GlowFilter([color:Number], [alpha:Number], [blurX:Number], [blurY:Number], [strength:Number], [quality:Number], [inner:Boolean], [knockout:Boolean])"
				break
			case "bevelFilter": // biseau			
				aProp = ["distance","angle","highlightColor","highlightAlpha","shadowColor","shadowAlpha","blurX","blurY","strength","quality","type","knockout"]
				sCodeHelp = "// BevelFilter([distance:Number], [angle:Number], [highlightColor:Number], [highlightAlpha:Number], [shadowColor:Number], [shadowAlpha:Number], [blurX:Number], [blurY:Number], [strength:Number], [quality:Number], [type:String], [knockout:Boolean])"
				break
			case "gradientGlowFilter": // rayonnement dégradé			
				aProp = ["distance","angle","colorArray","alphas","posArray","blurX","blurY","strength","quality","type","knockout"]
				//aProp = ["distance","angle","colors","alphas","ratios","blurX","blurY","strength","quality","type","knockout"]
				sCodeHelp = " //GradientGlowFilter([distance:Number], [angle:Number], [colors:Array], [alphas:Array], [ratios:Array], [blurX:Number], [blurY:Number], [strength:Number], [quality:Number], [type:String], [knockout:Boolean])"
				break
			case "gradientBevelFilter": // biseau dégradé			
				aProp = ["distance","angle","colorArray","alphas","posArray","blurX","blurY","strength","quality","type","knockout"]
				//aProp = ["distance","angle","colors","alphas","ratios","blurX","blurY","strength","quality","type","knockout"]
				sCodeHelp = "// GradientBevelFilter([distance:Number], [angle:Number], [colors:Array], [alphas:Array], [ratios:Array], [blurX:Number], [blurY:Number], [strength:Number], [quality:Number], [type:String], [knockout:Boolean])"
				break
			case "adjustColorFilter":
				aProp = [""]		
				fl.trace("!! adjustColorFilter : pas possible : en attente d'aspirine pour les matrices de couleurs !!")
				fl.trace("-- le plus simple si on veut la matrice : récupérer la matrice en ActionScript (pour ensuite la repasser en paramètre à 'ColorMatrixFilter'")
				fl.trace("-- pour récup la matrice : trace('mcCible.filters[0].matrix') ")
				return;
				
				// On peut récupérer ces infos en jsfl :
				// brightness: 32 [number]
				// contrast: -4 [number]
				// saturation: 16 [number]
				// hue: -60 [number]
				// TODO : transformer ces valeurs en matrice 4x5 pour le filtre 'ColorMatrixFilter'
				
				// matrice: 0.98159795999527,1.10689556598663,-1.128493309021,0,33.2600059509277,-0.166841864585876,0.765261590480804,0.361580222845078,0,33.2600021362305,0.977475643157959,-0.652646481990814,0.635170817375183,0,33.2600021362305,0,0,0,1,0
				break
			default:
				// rien		
		}		
		
		var sClasseFiltre = sNomFiltre.charAt(0).toUpperCase() + sNomFiltre.substring(1)
		
		// -- Les paramètres Flash
		fl.trace("\n")
		fl.trace('---- Paramètres Flash du filtre ' + sClasseFiltre + " ----")
		var pCible = oFilter
		for (var x in pCible) fl.trace(x+": "+pCible[x]+" ["+typeof pCible[x]+"]")		
		
		// Code du Filtre
		var sFilterCodeName = "fi" + sClasseFiltre
		var sCode = "var " + sFilterCodeName + ":" + sClasseFiltre + " = new " + sClasseFiltre
		sCode += "("
		var nLength = aProp.length
		var oValeur = ""				
		
		for (var i = 0; i < nLength; i++) {		
			var sProp = aProp[i]

			switch (sProp) {
				case "alpha":				
					oValeur = this.getAlphaColor(oFilter["color"])
					break
				case "highlightAlpha": // pour 'bevelFilter'
					oValeur = this.getAlphaColor(oFilter["highlightColor"])
					break				
				case "shadowAlpha": // pour 'bevelFilter'
					oValeur = this.getAlphaColor(oFilter["shadowColor"])				
					break				
				case "quality":
					oValeur = this.getQualityValue(oFilter[sProp]) 
					break	
				case "strength":
					oValeur = oFilter[sProp]/100
					break
				case "color":
					oValeur = this.getColor(oFilter[sProp])
					break		
				case "highlightColor":
					oValeur = this.getColor(oFilter[sProp])
					break	
				case "shadowColor":
					oValeur = this.getColor(oFilter[sProp])
					break	
				case "type":
					oValeur = "\"" + oFilter[sProp] + "\""
					break					
				case "colorArray":
					var aColors = oFilter[sProp]
					nParams = aColors.length
					oValeur = []
					for(var j = 0; j < nParams; j++) { oValeur.push(this.getColor(aColors[j])) }
					oValeur = "[" + oValeur + "]"				
					break		
				case "posArray":				
					oValeur = "[" + oFilter[sProp] + "]"
					break				
				case "alphas":				
					nParams = aColors.length
					oValeur = []
					for(var j = 0; j < nParams; j++) { oValeur.push(this.getAlphaColor(aColors[j]))	}				
					oValeur = "[" + oValeur + "]"	
					break
				case "matrix":					

					break	
				default:
					oValeur = oFilter[sProp]
			}			
			
			sCode += oValeur
			if (i==nLength-1) { sCode+= ")" } else { sCode+=", " }
		}		
		
		sCodeDeb += "import flash.filters." + sClasseFiltre + "\n"		
		sCodeFiltre += sCode + "\n"	
		sCodePush += "aFilters.push(" + sFilterCodeName + ")" + "\n"
		sCodeHelpFinal += sCodeHelp	
	}	
	
	var sCodeFinal = ""
	var sCodeInit_01 = "var aFilters:Array = new Array()" 
	var sCodeInit_02 = sNomOccurence + ".filters = aFilters"	
	
	sCodeFinal += sCodeDeb
	sCodeFinal += sCodeFiltre
	sCodeFinal += sCodeInit_01 + "\n"
	sCodeFinal += sCodePush
	sCodeFinal += sCodeInit_02 + "\n"
	sCodeFinal += sCodeHelpFinal + "\n"
	
	fl.trace("\n")
	fl.trace('---- Code AS du filtre --- ')
	fl.trace(sCodeFinal)
}


// ------------- UTILS -----------------------------------------------
function getQualityValue(sValue) {
	//quality : low = 1 (Inférieur), medium = 2 (Moyenne), high = 3 (Elevée)
	var oValue = new Object()
	oValue.low = 1
	oValue.medium = 2
	oValue.high = 3
	return oValue[sValue]
}

function getColor(sValue) {	// renvoie une couleur du type 0xFFFFFF à partir de '0#FFFFFF'
	return "0x" + sValue.substring(2, 8).toUpperCase()
}

function getAlphaColor(sValue) { // '#3366ffb3' -> b3 -> 0.7019... // renvoie la valeur alpha d'une couleur de la forme '#3366ffb3'
	var sAlpha = sValue.substring(8, 10)
	if (sAlpha.length==2) { return Number("0x"+sAlpha)/255 } else { return 1 }
}



// ---------- INFOS --------------------

// dropShadowFilter
// blurFilter
// glowFilter
// bevelFilter
// gradientGlowFilter
// gradientBevelFilter
// adjustColorFilter

// filter.angle -- Nombre en virgule flottante spécifiant l'angle de l'ombre ou de la couleur de surbrillance, exprimé en degrés. 
// filter.blurX -- Nombre en virgule flottante spécifiant la quantité de flou dans la direction  x, exprimée en pixels.
// filter.blurY -- Nombre en virgule flottante spécifiant la quantité de flou dans la direction  y, exprimée en pixels.
// filter.brightness -- Nombre en virgule flottante spécifiant la luminosité du filtre. 
// filter.color -- Chaîne, valeur hexadécimale ou entier représentant la couleur du filtre. 
// filter.contrast -- Nombre en virgule flottante spécifiant la valeur de contraste du filtre. 
// filter.distance -- Nombre en virgule flottante spécifiant la distance, en pixels, entre l'effet du filtre et un objet. 
// filter.hideObject -- Valeur booléenne indiquant si l'image source est masquée (true) ou affichée (false). 
// filter.highlightColor -- Chaîne, valeur hexadécimale ou entier représentant la couleur de soulignement. 
// filter.hue -- Nombre en virgule flottante spécifiant la teinte du filtre.
// filter.inner -- Valeur booléenne indiquant si l'ombre est intérieure (true) ou non (false). 
// filter.knockout -- Valeur booléenne indiquant si le filtre masque (true) ou non (false) l'image source.
// filter.name -- Chaîne spécifiant le type de filtre (propriété en lecture seule).
// filter.quality -- Chaîne spécifiant la qualité du flou. 
// filter.saturation -- Nombre en virgule flottante spécifiant la valeur de saturation du filtre. 
// filter.shadowColor -- Chaîne, valeur hexadécimale ou entier représentant la couleur de l'ombre. 
// filter.strength -- Entier spécifiant l'intensité du filtre en pourcentage.
// filter.type -- Chaîne spécifiant le type de biseau ou de néon.