Comme suggéré dans le blog de Stéfane Funaro, créer un formulaire de saisie en Flash pour les commentaires d'un blog permet de se mettre à l'abris de manière quasi-complète des "blogspams" ... J'ai mis en place ici ce type d'outil. Pour ceux qui avaient choisis de garder un cookie du blog pour mémoriser leurs noms, email, et site web, vous pouvez l'effacer, étant donné que c'est un ShardeObject qui est maintenant utilisé !

En ce qui me concerne, ayant un blog "fait maison", je n'ai pas encore eu à faire face a des spammeurs, mais c'est surtout pour des raisons pratiques de formatage du texte par les BBCode que j'ai fait ce formulaire en Flash. Je n'ai pas pris la peine de faire un preload pour les 2,26Ko occupés par l'animation ... 8|

Le problème qui s'est posé à moi est que la classe Selection est assez capricieuse : en effet, elle ne permet de connaitre la zone sélectionnée que pour un élément ayant le focus. Or, lorsque l'on clique sur un bouton, ce bouton prend le focus, et on perd donc les informations concernant le texte qui est selectionné. J'ai donc créé une mini-classe qui permet de garder en permanence la sélection faite sur une zone de texte donnée, et de lui appliquyer des "tags" : dans le cas de ce blog, ces tags sont bien évidemment des BBCodes ...

Je vous la livre telle quelle, vite faite et vite commentée ! :oops:/**
* TextFormater
* Premier brouillon, v0.0 alpha
*
* Surveille la sélection dans un champ texte
* et fournit les outils pour le formater
*/
class TextFormater {
        // TextField à formater
        private var _textfield:TextField;
        // Position de début et de fin de la sélection
        private var _begin:Number;
        private var _end:Number;
        // Constructeur
        // Prend en paramètre le champ texte à formater
        function TextFormater ($tf:TextField) {
                this._textfield = $tf;
                // On crée une propriété dans le TextField
                // qui pointe vers l'objet TextFormater
                this._textfield._formater = this;
                // Quand le champ texte prend le focus
                // on surveille la selection
                this._textfield.onSetFocus = function() {
                        this._formatInterval = setInterval(this._formater,"checkSelection",50);
                }
                // Quand le champ texte perd le focus
                // on arrête de le surveiller
                this._textfield.onKillFocus = function() {
                        clearInterval(this._formatInterval);
                }
        }
        // Surveille la sélection faite dans le champ texte
        function checkSelection() {
                // Si le champ texte a bien le focus
                if (eval(Selection.getFocus()) == this._textfield) {
                        // On renseigne le début et la fin de la selection
                        this._begin = Selection.getBeginIndex();
                        this._end = Selection.getEndIndex();
                }
        }
        // Ajoute un "tag" (BBCode ou autre) au début
        // et à la fin de la sélection
        function addTag($begin:String, $end:String) {
                var txt:String = this._textfield.text;
                // Encadre la sélection avec les tags
                this._textfield.text = txt.slice(0,this._begin) + $begin + txt.slice(this._begin,this._end) + $end + txt.slice(this._end);
                // Donne le focus au champ texte et sélectionne
                // le texte encadré par les tags
                Selection.setFocus(this._textfield);
                Selection.setSelection(this._begin,this._end + $begin.length + $end.length);
        }
}

J'espère que ce formulaire vous rendra la vie plus facile pour égayer vos commentaires, en attendant la version W3C du blog, et les versions Flash du blog et de mon site perso. ^^

Je me suis aperçu d'une utilisation assez singulière de la chaine de portées avec l'instruction with, qui permet de limiter la répétition à outrance de l'endroit ou sont situées des propriétés ou méthodes.

Ces deux with imbriqués rajoutent à la chaîne de portées (dans l'ordre de recherche) : le clip crée (sq) et l'objet square. Donc, les instructions vont chercher d'abord dans le clip, et y trouver les méthodes et propriétés _x, _y, lineStyle, moveTo, etc... puis dans l'objet, pour y trouver les propriétés x, y, etc... Et voila, aucune portée n'est répétée à chaque ligne !

Par contre, cette imbrication est à utiliser avec précaution, étant donné que si le clip possède une propriété ayant le même nom qu'une propriété de l'objet square, c'est celle du clip qui sera utilisée en priorité ... 8|

Du temps de mon premier pathfinder, j'avais crée une petit classe Point2, qui contenait des coordonnées. Je voulais également qu'elle soit dynamique, afin d'y mettre les propriétés que je voulait. Le problème était de taper 15 lignes de codes s'il y avait un nombre important de propriétés, et j'ai donc crée cette petite méthode setter pour me faciliter la vie.

dynamic class Dummy {
        function Dummy() {
                // ....
        }
        function set props(o:Object) {
                for (var curProp in o) {
                        this[curProp] = o[curProp];
                }
        }
        function get props():String {
                var prStr:String = "{ ";
                var writeComma:Boolean = false;
                for (var curProp in this) {
                        prStr += writeComma ? "," : "";
                        prStr += curProp+":"+this[curProp]+" ";
                        writeComma = true;
                }
                prStr += "}";
                return prStr;
        }
} Rien de bien fantastique dans ces quelques lignes, mais c'est son utilisation qui est bien pratique :var myObj = new MyClass();
myObj.props = {name:"LAlex", x:10, y:20};
trace(myObj.name); // LAlex
trace(myObj.x); // 10
trace(myObj.props); // {y:20 ,x:10 ,name:LAlex }

Evidemment, ce n'est pas ce qu'il y a de plus "propre", mais ca peut aider a faire des raccourcis dans le code assez pratiques. Ca ne peut également pas être utilisé pour des initialisation multiples comme a=b=c. Pour pouvoir faire cela, il aurait fallu pouvoir retourner une valeur dans le setter, mais ce n'est pas possible comme je l'ai déjà dit dans ce blog ... Alors tant qu'à faire, autant que ca serve pour faire un affichage "pratique" !

J'ai mis en pratique les optimisations qui m'ont été suggérées par Timothee Groleau, et voici donc une version plus optimisée de la classe StringUtils. J'ai également mis en place mon autre implémentation de la méthode reverse, qui se révèle plus performante (MM a bien travaillé sur les tableaux apparemment 8)) ...

Je n'ai finalement pas intégré l'encodage MD5, pour une raison tout bête, qui est que c'est long ! En fait, c'est un surcroit de poids (quelques Ko), pour une utilisation moins fréquente que les fonctionnalités actuelles de la classe. Il me paraît mieux de faire une classe dédiée à l'encodage par exemple. Vous pourrez trouver son implémentation par neo-lao dans le commentaire de ce post.

En passant, neo-lao est un de mes partenaires de Flash Forum et il a ouvert un petit site de ressources, ou il mets à disposition ses réalisations Flash et autres : neo-lao ressources.

Code de la classe StringUtils/*************************
* StringUtils.as v0.2
* Fonction "utilitaires" de traitement
* des chaînes de caractères
*
*-------------------
* LAlex
* <a href="http://www.lalex.com/">http://www.lalex.com/</a>
*
* ------------------
* Aide à l'optimisation lTrim, rTrim et trim
* Thimothee Groleau
* <a href="http://www.timotheegroleau.com/">http://www.timotheegroleau.com/</a>
*
**************************/
class com.lalex.utils.StringUtils {
        // Caractères considérés comme caractères d'espacement
        private static var DEFAULT_SPACECHARS:String = "

\t";
        // StringUtils.replace
        // Cherche une suite de caractères dans une chaine
        // pour la remplacer par une autre
        // ----------
        // $str : Chaine de caractêres à traiter
        // $search : Chaine de caractère à chercher
        // $replace : Chaine de caractère de remplacement
        public static function replace($str:String, $search:String, $replace:String):String {
                return $str.split($search).join($replace);
        }
        private static function spaceStringToObject($space:Object):Object {
                var spObj:Object = new Object();
                // Si aucun caractères n'est spécifié, utilise
                // les caractères par défaut.
                if ($space == undefined) {
                        $space = DEFAULT_SPACECHARS;
                }
                if (typeof $space == "string") {
                        // Remplit l'objet
                        var spLen:Number = $space.length;
                        while(--spLen >= 0) {
                                spObj[$space.charAt(spLen)] = true;
                        }
                } else {
                        spObj = $space;
                }
                return spObj;
        }
        // >> private <<
        //
        // StringUtils._lTrim
        // On supprime tous les caractères d'espacement
        // au début de la chaine de caractères. Un objet
        // dont les propriétés sont les caractères d'espacement
        // lui est transmis.
        private static function _lTrim($str:String,$space:Object):String {
                // Longueur de la chaine restante
                var strLen:Number = $str.length;
                // Position actuelle
                var strPos:Number = 0;
                // Tant que la chaine n'est pas vide
                while (strLen > 0) {
                        // Si on ne trouve pas un espace, on arrete la boucle
                        if (!$space[$str.charAt(strPos)]) {
                                break;
                        }
                        // On avance d'une position
                        strPos++;
                        // On raccourcit "virtuellement" la chaine
                        strLen--;
                }
                // On retourne la chaine sans les caractères trouvés.
                return $str.slice(strPos);
        }
        // >> private <<
        //
        // StringUtils._rTrim
        // On supprime tous les caractères d'espacement
        // à la fin de la chaine de caractères. Un objet
        // dont les propriétés sont les caractères d'espacement
        // lui est transmis
        private static function _rTrim($str:String,$space:Object):String {
                // Longueur de la chaine restante
                var strLen:Number = $str.length;
                // Position actuelle
                var strPos:Number = strLen-1;
                // Tant que la chaine n'est pas vide
                while (strLen > 0) {
                        // Si on ne trouve pas un espace, on arrete la boucle
                        if (!$space[$str.charAt(strPos)]) {
                                break;
                        }
                        // On avance d'une position
                        strPos--;
                        // On raccourcit "virtuellement" la chaine
                        strLen--;
                }
                // On retourne la chaine sans les caractères trouvés.
                return $str.slice(0,strPos+1);
        }
        // StringUtils.lTrim
        // On supprime tous les caractères d'espacement
        // au début de la chaine de caractères. Une chaine
        // dont dont chaque caractère est un caractère d'espacement
        // lui est transmise.
        public static function lTrim($str:String,$space:String):String {
                return _lTrim($str, spaceStringToObject($space));
        }
        // StringUtils.rTrim
        // On supprime tous les caractères d'espacement
        // à la fin de la chaine de caractères. Une chaine
        // dont dont chaque caractère est un caractère d'espacement
        // lui est transmise.
        public static function rTrim($str:String,$space:String):String {
                return _rTrim($str, spaceStringToObject($space));
        }
        // StringUtils.trim
        // On supprime tous les caractères d'espacement
        // au début et à la fin de la chaine de caractères. Une chaine
        // dont dont chaque caractère est un caractère d'espacement
        // lui est transmise.
        public static function trim($str:String, $space:String):String {
                var sp:Object = spaceStringToObject($space);
                return _rTrim(_lTrim($str, sp), sp);
        }
        // StringUtils.stringToArray
        // Convertit une chaine de caractères en tableau
        // contenant un caractère par index.
        public static function stringToArray($str:String):Array {
                return $str.split("");
        }
        // StringUtils.arrayToString
        // Transforme un tableau en chaine de caractère
        // constituée de la concatenation de ses éléments.
        public static function arrayToString($ar:Array):String {
                return "" + $ar.join("");
        }
        // StringUtils.reverse
        // Inverse l'ordre des caractères d'une chaine
        public static function reverse($str:String):String {
                // Transforme la chaine en tableau.
                var ar:Array = $str.split("");
                // Inverse le tableau
                ar.reverse();
                // Transforme le tableau inversé en chaine.
                return ar.join("");
        }
}

::Télécharger StringUtils.zip::

Toujours sur mon moteur de tilegame en MVC (d'abord en 2D, puis en 3D iso), j'utilise pour la diffusion de mes évenements la classe BroadcasterMX au moyen de l'héritage. Ca permet de ne pas passer par la méthode initialize(), et également d'initialiser le prototype au lieu de l'instance.

Or, il se trouve que cette classe ne possede pas de constructeur !!! 8O Ce qui oblige a initialiser le tableau _listeners dans le constructeur de la classe fille. Une petite modification simple consiste donc à rajouter trois ligne dans le code de la classe :function BroadcasterMX() {
   this._listeners = new Array();
}Il suffit ensuite de faire un simple super() dans la classe fille ...

Oulala, et l'EULA ? Je vais me faire taper sur les doigts moi !!!

Je n'arrive pas à trouver un moyen de faire du cast, tout en continuant à utiliser le typage fort de MX 2004 ... :? En fait, une simple utilisation du constructeur permet de ne pas provoquer d'erreur de compilation, mais au lieu de faire un downcast, cela me renvoie null ...

Pour ceux qui ne connaissent pas le terme "downcast", ca correspond à changer le type d'un instance vers une classe qui hérite de sa classe actuelle. Cette classe est en fait située "plus bas" dans la chaîne d'héritage, et le cast est la conversion d'un type à un autre, d'où le terme de downcast ... Par exemple, une voiture est un véhicule, mais un véhicule n'est pas forcément une voiture. Si on a une instance d'un véhicule et qu'on la caste vers la classe voiture, on va downcaster cette instance ... Un cast dans l'autre sens (de voiture vers véhicule) est un upcast, et il est le plus souvent effectué de manière implicite ...

Revenons à ce que je disais :// classe Parent
class Parent {
        function Parent() {
        }
        function doIt() {
                trace("doIt");
        }
        function toString():String {
                return "Parent instance";
        }
}
// classe Child
class Child extends Parent {
        function Child() {
                super();
        }
        function doItChild(test:Child) {
                trace(">> doItChild");
                trace(test);
        }
        function toString():String {
                return "Child instance";
        }
}
/********** Utilisation **********/
var par : Parent = new Parent();
trace(par); // Parent instance
var chi : Child = new Child();
chi.doItChild(Child(par));
// >> doItChild
// null

Je ne vois pas dans ce cas la ce qui pourrait empêcher le downcast, mais apparemment ca lui pose un problème ... 8| Décidemment, ce typage fort pose plus de problèmes qu'il n'en résout ... :? D'ailleurs, vous devez commencer à me trouver lourd avec ca car je n'ose pas compter combien de posts j'ai fait sur ce sujet !!! Mais la je me retrouve encore une fois à buter la dessus, et ca me fais enrager une fois de plus !!! :?

J'ai voulu essayer les interactions possibles entre Flash et javascript, que ce soit dans une sens (appel d'une fonction javascript avec Flash), ou dans l'autre (interaction sur l'animation Flash avec Javascript) ... Eh bien je suis assez déçu des performances ... Je pense que ce sont les performances du javascript qui sont un peu légères ... 8|

Ce test consiste en fait à regarder en permanence la position d'une popup, et de déplacer un movieclip dans l'animation Flash pour donner l'impression que la popup est un masque que l'on peut déplacer par drag&drop .... Vous pouvez aussi télécharger l'archive qui en contient le code ... Voir le test (testé sur IE, je ne sais pas si ca marche sur les navigateurs de type mozilla ou opera)

::Télécharger js-flash.zip::