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::

Voici une petite astuce que je pratique depuis longtemps en me basant sur ma propre logique, mais je me suis décidé à la benchmarquer (euh ... ca s'écrit comme ca ? :roll:)

Il s'agit d'éviter le plus possible d'accéder à un élément de tableau (pendant une boucle par exemple) ou à sa longueur. Si l'on a besoin d'accéder plusieurs fois au même élément d'un tableau, il est plus performant de le mettre dans une variable, la modifier, puis la remettre dans le tableau (évidemment, si c'est un objet, vous n'avez pas besoin de la remettre dans le tableau ;)). Le principe est le même pour la longueur du tableau.

Voici le "bench" que j'ai fait// On crée un tableau de 100.000 cases
var tst = new Array(100000);
// On va accéder à un élément
// situé peu à prés au milieu (60.000)
tst[60000] = 10;
/** Accés au tableau à chaque boucle **/
var t = getTimer();
for (var i=0 ; i<200000 ; i++) {
        // Accés à la longueur
        tst.length;
        // Accés à l'élément
        tst[60000] += 1;
}
// Affichage du temps
trace("Accés au tableau : " + (getTimer() - t) + " ms.");
// Reinitialisation de la valeur
tst[60000] = 10;
/** Accés à une variable **/
t = getTimer();
// Initialisation de la variable
var elt = tst[60000];
// Initialisationde la longueur
var ln = tst.length;
for (var i=0 ; i<200000 ; i++) {
        // Acces à la valeur de la longueur
        ln;
        // Modification de la valeur
        elt += 1;
}
// On remet la valeur dans le tableau
tst[60000] = elt;
// Affichage du temps
trace("Accés aux variables : " + (getTimer() - t) + " ms."); Ce qui nous donne en sortieAccés au tableau : 3217 ms. Accés aux variables : 2367 ms.Le gain est en général de l'ordre d'une seconde, ce qui est énorme ! 8O Ca ne parait pas grand chose, mais réflechissez à toutes les boucles for que vous faites sur un tableau, en testant la longueur comme condition d'arrêt ... Il accéde à la propriété length à chaque boucle !!! :roll: Il vaut mieux mettre la longuer dans une variable qui va servir pour la condition du for. Sinon, si l'ordre vous importe peu, vous pouvez utiliser une boucle while qio commence par la longuer du tableau/**** Mauvaise utilisation ****/
for (var i=0 ; i<monTableau.length ; i++) {
   // ...
}
/**** Bonne utilisation ****/
var len:Number = monTableau.length;
for (var i=0 ; i<len ; i++) {
   // ...
}
/*** Autre bonne utilisation ****/
var i:Number = monTableau.length;
while (--i >= 0) {
   // ...
}
Vous pouvez aussi utilise for ( ... in ...), mais je ne sais pas comment ca marche ...:P

Ce n'est certainement pas nouveau pour beaucoup d'entre vous, mais ca peut toujours servir ...

Pour ceux qui n'ont pas suivi les commentaires du post sur un inconvénient du typage fort, Timothee Groleau et moi nous sommes aperçu qu'un vieux bug issu de Flash 5, corrigé sur Flash MX, a refait surface dans Flash MX 2004. Il s'agit du bug de constructor lors de l'héritage.

En effet, lors de l'héritage, dans une classe fille, la propriété this.constructor pointe sur le constructeur de la classe parent, que ce soit en AS1 ou en AS2. Le problème dans Flash 5 avait été évoqué par Dave Yang : http://www.quantumwave.com/flash/inheritance.html.

Pour exemple, voici un héritage fait en AS1 au moyen de la méthode préconisée par Macromedia, avec l'instruction new :_global.Parent = function() {};
_global.Child = function() {};
Child.prototype = new Parent();
Child.prototype.doIt = function() {
        trace("isParent ? " + (this.constructor == Parent));
        trace("isChild ? " + (this.constructor == Child));
}
var obj = new Child();
obj.doIt(); Compilé avec Flash MX, la sortie est logiquement :isParent ? false isChild ? true Par contre, compilé avec Flash MX 2004, la sortie est isParent ? true isChild ? false De la même manière, l'AS2 utilise égallement la méthode new de Macromedia lors de sa traduction en AS1, et on a donc le même problème :class Child extends Parent {
  // ....
  function doIt() {
   trace(this.constructor == Parent);
  }
}
var c:Child = new Child();
c.doIt(); // true Le seul moyen qui avait été trouvé pour rectifier ce problème avec Flash 5 était d'initialiser this.constructor à la main dans le constructeur : class Parent {
  function Parent() {
    this.constructor = Parent;
    // ...
  }
}
class Child extends Parent {
  function Child() {
    super();
    this.constructor = Child;
    // ...
  }
}
C'est quand même incroyable que Flash qui se veut maintenant un outil de développement complètement orienté objet ait encore ce genre de disfonctionnements! :? Il ne reste plus qu'à espérer qu'un patch pour MX 2004 tant attendu par tous les développeurs Flash réctifie ce problème ... :roll:

Au fait, vous avez remarqué ? La colorisation de l'AS2 se fait correctement maintenant !

Je profite de mes dernières heures de trial MX 2004 au bureau (eh eh, je l'ai pas installé à la maison 8)) pour pousser un (autre) coup de gueule sur la traduction de l'AS2 en AS1 ...

Décidemment, AS2 a beau être plus sympa à utiliser, le fait de poser les limitations du typage fort au moment de la compilation n'arrête pas de m'embêter. Il oblige à réécrire deux fois le même code, ce qui va entièrement à l'encontre des principes de base de la POO ... :?

Je veux créer deux classes dont l'une hérite de l'autre. Les constructeurs de ces deux classes prennent les mêmes paramètres. Je veux alors créer une méthode clone qui va me retourner un clone de l'objet (jusque là, rien de bien original). Pourtant, je vais être obligé de réécrire cette méthode pour la classe fille, car le typage fort m'empêche de créer une méthode dans la classe mère qui fonctionnera pour la classe fille. Dans le pire des cas, je veux bien me passer du typage fort pour la fonction clone (ou juste réécrire le typage de la méthode), mais pas réécrire la méthode entière !

Voila ce que je suis obligé de faire :
// classe Parent
class Parent {
   var _prop1:Number;
   var _prop2:Number;
   function Parent(p1:Number) {
      this._prop1 = p1;
      this._prop2 = p1;
   }
   function clone() : Parent {
      var ret : Parent = new Parent(this._prop1);
      return ret;
   }
}
// classe Child
class Child extends Parent {
   function Child(p1:Number) {
      super(p1);
      this._prop2 = p1 + 10;
   }
   function clone() : Child {
      var ret : Child = new Child(this._prop1);
      return ret;
   }
} Et voila ce que j'aimerais (je devrais ?) pouvoir faire// classe Parent
class Parent {
   var _prop1:Number;
   var _prop2:Number;
   function Parent(p1:Number) {
      this._prop1 = p1;
      this._prop2 = p1;
   }
   function clone() : Parent {
      var ret : Parent = new this.constructor(this._prop1);
      return ret;
   }
}
// classe Child
class Child extends Parent {
   function Child(p1:Number) {
      super(p1);
      this._prop2 = p1 + 10;
   }
   function clone() : Child {
      return super.clone();
   }
} La deuxième possibilité serait possible avec un typage fort à l'execution (runtime) et pas à la compilation. J'ai bien essayé d'enlever le typage de la méthode clone (typage du retour et typage de la variable ret), mais il ne m'autorise pas à faire le new this.constructor, prétextant que this.constructor n'est pas une fonction, et en m'affichant comme message : A function call on a non-function was attempted. var ret = new this.constructor(this._prop1); Pourtant, le script suivant ne peut pas mentir :roll:trace(typeof this.constructor); // Affiche : function