Lors qu'une classe hérite d'une autre, tout l'interêt est bien évidemment de ne pas réimplémenter les methodes de la classe mère. En effet, en l'absence d'une méthode portant le nom demandé, la méthode de la classe mère est appelée, transmettant ainsi tous les arguments. Eh bien ce qui est dommage, c'est que ce n'est pas le cas du constructeur... :\

En effet, si une classe mère prend un argument en paramètre, et qu'une classe fille hérite de cette dernière sans implémenter de constructeur, les paramètres passés au constructeur de la classe fille ne seront pas transmis.

La preuve par l'exemple: j'utilise actuellement un ensemble de managers gérant chacun des objets (Contacts, Articles, etc...) dont les classes implémentent toutes la même interface. Le but est donc de créer un manager "de base" (non instanciable) qui factorise les comportements communs... Chaque manager est lié à un contexte dans l'application, qui est passé en paramètre au constructeur du manager:
/* == Classes utilisées
interface Item
class Contact implements Item
class Context
*/
// Classe mère
class BaseManager {
   private var _context:Context;
   private var _selectedItem:Item;
   // Le constructeur prend un paramètre
   private function BaseManager(ctx : Context) {
      _context = ctx;
   }
   public function getContext() : Context {
      return _context;
   }
   public function getSelectedItem() : Item {
      return _selectedItem;
   }
   private /*protected*/ function setSelectedItem(i : Item) {
      if (i != _selectedItem) {
         _selectedItem = i;
         dispatchEvent({type:"selectionChanged", selected:_selectedItem});
      }
   }
}
class ContactManager
   extends BaseManager {
   // Force le typage à 'Contact'
   private function setSelectedItem(c : Contact) {
      super.setSelectedItem(c);
   }
   public function getSelectedContact() : Contact {
      return Contact(getSelectedItem());
   }
}
// Création du contexte
var ctx:Context = new Context("mainApp");
// Création du ContactManager
var contactManager:ContactManager = new ContactManager(ctx);
// Affichage du contexte
trace(contactManager.getContext()); // undefined Ceci est trés certainement du à la conversion en AS1. En effet, en AS1, déclarer une classe revient à déclarer son constructeur, et donc a relayer "manuellement" les paramètres du constructeur si besoin. Le "compilo" AS2 du coup crée automatiquement un constructeur dont le code est:function ContactManager() {
   super();
} alors que dans mon cas, il faut que je crée le constructeur moi-même:function ContactManager(c : Context) {
   super(c);
}
C'est peut-être déjà connu de beaucoup, mais moi j'ai cherché un p'tit moment quand-même... Bref, cela revient encore et toujours au problème d'appeler le constructeur d'une classe mère avec un nombre indéfini d'arguments (l'idéal étant avec apply)... :\

Le passage à FDT n'est pas toujours sans douleurs... Les habitudes évoluent, et la façon de coder varie inmanquablement. Un des problèmes auxquels je me suis trouvé confronté a été l'utilisation de la commande 'trace', que l'on peut bien évidemment remplacer par un appel de méthode via l'option -trace de MTASC... Comme j'en ai déjà parlé, j'utilise la console SOS, pour le côté pratique de la connexion socket que sont la connexion à une console sur une machine distante, ou la gestion d'une couleur de fond différente par application (TRES utile !!!)

Le moyen que j'utilise aujourd'hui afin d'éviter les problèmes de non-importation de la classe s'occupant de se connecter à la console consiste à créer un petit répertoire utilitaire contenant les classes utiles à FDT, et de l'inclure dans mes "Linked librairies", et d'en appeler une méthode start(). Pour l'instant, seule le connecteur à la console est présent, mais il se peut que d'autres suivent (notamment mon petit framework de profiling, a venir plus tard :P)

Bref, voici ma classe SOSTracer, utilisée par MTASC avec l'option -trace SOSTracer.out :
/**
 * @author LAlex
 * @version 0.1
 * @since 2006-01-05
 */
class SOSTracer {
        // Console infos
        public static var SOS_HOST:String = "localhost";
        public static var SOS_PORT:Number = 4444;
        // Used for static method 'out'
        private static var __instance:SOSTracer;
        // Used for line number display
        private static var __lineNumber:Number = 1;
        // Allow to display line numbers
        public static var enableLineNumber:Boolean = false;
        // Static function, used for MTASC -trace option
        // SOSTracer.start() must be called before
        public static function out(o) {
                __instance.trace(o);
        }
        // Launch the static SOSTracer with
        // given background color
        public static function start(col:Number):Boolean {
                __instance = new SOSTracer(col);
                return true;
        }
        private var _bufferize:Boolean = true;
        private var _socket: XMLSocket;
        private var _isConnected:Boolean = false;
        private var _color:Number;
        // For later ;oP
//      private var _itv:Number = -1;
        // Buffer
        private var _stack: Array;
        function SOSTracer(col:Number) {
                if (col != undefined) {
                        _color = col;
                }
                _stack = [];
                _socket = new XMLSocket();
                _socket.onConnect = function (suc) {
                        var tr = arguments.callee.tracer;
                        tr._connected(suc);
                };
                _socket.onConnect.tracer = this;
                _socket.connect(SOS_HOST, SOS_PORT);
        }
        // Launched on socket connection
        private function _connected(sc:Boolean) {
                if (sc) {
                        if (_color != undefined) {
                                _socket.send("!SOS<appColor>" + _color + "</appColor>");
                        }
                        _flush();
                        _isConnected = true;
                } else {
                        _bufferize = false;
                        throw new Error("SOS Socket connection failed");
                }
        }
        // Flush buffer
        private function _flush() {
                while(_stack.length) _socket.send(_stack.shift());
        }
        // Display a string (or object representation)
        public function trace(o) {
                var no:String = (enableLineNumber ? "[" + __lineNumber++ + "] " : "") + o.toString();
                if (_isConnected) {
                        _socket.send(no);
                } else if (_bufferize) {
                        _stack.push(no);
                }
        }
} Le but est ici d'être indépendant de tout autre package, d'où l'utilisation d'une classe XMLSocket "de base" (j'en ai implémenté une plus évoluée), et l'utilisation d'un Delegate "à la main" Afin d'éviter de surcharger la connexion, je prévois ensuite d'utiliser un système de bufferisation éventuel, au moyen du buffer utilisé avant la connexion, et d'un setInterval (vous avez surement remarqué que la propriété pour l'intervalle est déjà prévue, mais pas utilisée encore :$). Pour l'utiliser, rien de plus simple, je lance un start() dans mon main et j'utilise trace() dans mon code : public static function main() {
        SOSTracer.start(0XFFFFCC); // Couleur de fond dans la console
}

Pour le déploiement, il suffit de changer dans MTASC l'option -trace SOSTracer.out par -trace no, et de commenter la ligne SOSTracer.start() (pas de import à commenter, du fait de l'absence de package 8))

::Télécharger SOSTracer.zip::

Le compilateur de Flash 8 semble contenir un bug qui, s'il est mineur, peut provoquer quelques arrachages de cheveux. En fait, lorsque l'on hérite d'une classe en précisant son chemin complet (donc sans import), le compilo va la considérer comme importée, mais ce n'est pas le cas à l'éxecution. La où l'on s'attend donc à obtenir une erreur de compilation, tout se passe bien, et on comprend donc mal où est l'erreur... :\

Petit exemple :class com.lalex.myappli.CustomSocket extends com.lalex.net.ExtendedSocket {
   function CustomSocket() {
      /**
      * ExtendedSocket.CONNECT_FAILED sera 'undefined'
      * car on a pas importé com.lalex.net.ExtendedSocket
      * Pourtant, le compilo laisse passer
      */
      addEventListener(ExtendedSocket.CONNECT_FAILED, this, handleConnectionFail);
   }
   private function handleConnectionFail(o) {
      trace("Connection failed");
   }
}
Bon, je vous l'accorde, on pourrait dire "Ben il n'avait qu'à importer la classe", ou "Il n'avait qu'à donner le chemin complet de la classe!"... mais le compilateur n'est-il pas là pour nous signaler ce genre d'oublis? :o

En tant qu'utilisateur, je trouve parfois assez exaspérant de devoir ouvrir, par exemple, un fichier PDF dans mon navigateur. Je préfère largement le télécharger et l'ouvrir avec Acrobat Reader...

Lorsqu'il s'agit d'un lien dans une page HTML, il est facile d'utiliser un clic droit (ou CTRL pour les maceux) pour pouvoir choisir entre l'ouvrir réellement ou le télécharger. Par contre, dans un site Flash c'est plus délicat...

C'es pourquoi j'ai créé vite-fait une petite classe qui permet d'assigner à un clip un menu contextuel qui va permettre soit d'ouvrir, soit de télécharger un fichier déterminé. Elle est basique pour l'instant, mais l'on peut prévoir de la faire évoluer avec quelques options (localisation, cible du getURL, comportement par défaut du onRelease, etc...). A noter que le téléchargement ne fonctionne que dans un environnement HTTP (cela est du aux restrictions de la classe FileReference), donc on oublie le test dans l'IDE Flash ou dans une page HTML accédée directement depuis le disque dur... import flash.net.FileReference;
import mx.utils.Delegate;
/**
 * FileLink
 *
 * @notice Can only be used in HTTP environment due to FileReference restrictions
 * @author  <a href="http://www.lalex.com/">LAlex</a>
 * @version 1.0
 * @since   
 */
class com.lalex.utils.FileLink {
        // File path
        private var _path:String;
        function FileLink(f:String) {
                _path = f;
        }
        /**
         * Assign a link to a movieclip, setting its context menu
         *
         * @usage   fLink.assignTo(myLinkButton, true, true);
         * @param   clip       MovieClip to click to obtain download menu
         * @param   setRelease Set the onRelease handler of the clip ?
         * @param   hide       Hide context menu builtin items ?
         */
        function assignTo(clip:MovieClip, setRelease:Boolean, hide:Boolean) {
                hide = !!hide;
                setRelease = !!setRelease;
                var dl:Function = Delegate.create(this, this.download);
                var op:Function = Delegate.create(this, this.open);
                var m:ContextMenu = new ContextMenu();
                m.customItems.push(new ContextMenuItem("Ouvrir", op));
                m.customItems.push(new ContextMenuItem("Télécharger", dl));
                if (hide)
                        m.hideBuiltInItems();
                if (setRelease)
                        clip.onRelease = op;
                clip.menu = m;
        }
        /**
         * Open a file in the browser
         * Used by a proxy (Delegate) function
         */
        private function open() {
                getURL(_path);
        }
        /**
         * Dowload the file to the local computer
         * Used by a proxy (Delegate) function
         */
        private function download() {
                var f:FileReference = new FileReference();
                f.download(_path);
        }
} Et voici son utilisation (celle du bouton ci-dessous)import com.lalex.utils.FileLink;
var fl:FileLink = new FileLink("files/FileLink.zip");
fl.assignTo(bt, true, true);

::Télécharger FileLink.zip::

Ca ne fait pas longtemps que je re-code en AS2 au quotidien. Et depuis que j'ai repris, j'utilise ma classe Debug intensivement, et la fait donc évoluer en fonction de mes besoins, et aussi des bugs qu'elle peut comporter...

Au programme de cette nouvelle version, tout d'abord le fait d'éviter une boucle infinie dans le cas ou un object est composé d'un autre, qui lui-même pointe vers son parent. En gros, c'est comme si on parcourait récursivement un clip, et sa propriété _parent...

Ensuite, une méthode éxécutée au premier appel de dump(), qui va parcourir toutes les classes présentes et leur créer une propriété contenant le nom de la classe, et une propriété conternant le nom du package. Cela permet d'afficher tout ca lors du dump d'un objet... En fait, c'est le seul moyen de retrouver le nom d'une classe sans le préciser dans le code de cette classe... Je crois me souvenir que Liguorien avait déjà évoqué ce sujet, s'inspirant de la partie reflection de la librairie as2lib...

Et troisièmement, la possibilité de spécifier un caractère qui permettra d'ignorer toute propriété dont le nom commence par celui-ci... Par exemple, il m'arrive d'utiliser une propriété contenant un XML dans mes classes. Il me suffit de faire commencer son nom par '$' (caractère par défaut) pour qu'elle ne soit pas incluses dans l'affichage...

/**
* Debug
* @version 0.2
* @package com.lalex.utils
*
* @author LAlex
* @since 2005-08-16
*/
class com.lalex.utils.Debug {
   /**
   * Property used to store class names
   */
   public static var classNameProperty:String = "__className";
   public static var packNameProperty:String = "__packName";
   private static var ignoreChar:String = "$";
   private static var __classInit:Boolean = false;
   /**
   * Trace an object detailled content
   * @param o Object to display
   */
   public static function dump(o) {
                if (!__classInit) {
                        initClassNames();
                        __classInit = true;
                }
                trace(dumpToString(o));
   }
        /**
        * Browse all classes and create a property for class name
        * and a property for package name
        * Browse is recursive
        * @param o Object containing classes
        * @param pa Package name
        */
   public static function initClassNames(o, pa:String) {
                if (!__classInit) {
                        o = o ? o : _global;
                        pa = pa.length ? pa : "";
                        for (var p in o) {
                                if (typeof o[p] == "function") {
                                        o[p][classNameProperty] = p;
                                        o[p][packNameProperty] = pa.length ? pa.substr(0, pa.length-1) : "";
                                        _global["ASSetPropFlags"](o[p], classNameProperty + "," + packNameProperty, 7);
                                } else if (typeof o[p] == "object") {
                                        initClassNames(o[p], pa + p + ".");
                                }
                        }
                }
        }
   /**
   * Return a string containing the object content. Recursive method
   * @param o Target object
   * @param d Depth. Used to generate tabs
   * @param a Array containing already dumped objects
   */
        private static function dumpToString(o, d:Number, id:Number):String {
                var ret:String = "[";
                d = d ? d : 0;
                id = id ? id : _dumped.push(new Array())-1;
                var dp:Number = d;
                var sp:String = "";
                while (d-- > 0) {
                        sp += "  ";
                }
                if (typeof o == "object") {
                        if ( o["__constructor__"][classNameProperty] ) {
                                ret += o["__constructor__"][classNameProperty] + " (" + o["__constructor__"][packNameProperty] + ")";
                        } else if (o instanceof Array) {
                                ret += "Array";
                        } else {
                                ret += "Object";
                        }
                        if (!o.__dumped) {
                                ret += "
" + sp;
                                o.__dumped = true;
                                _global["ASSetPropFlags"](o, "__dumped", 1);
                                _dumped[id].push(o);
                                for (var p in o) {
                                        if (typeof p != "function") {
                                                if (p.substr(0,1) != ignoreChar) {
                                                        ret += p + ": " + dumpToString(o[p], dp+1, id) + "
" + sp;
                                                }
                                        }
                                }
                        }
                        ret += "]";
                } else {
                        ret = o.toString();
                }
                var nd:Number = _dumped[id].length;
                while (nd-- > 0) {
                        var df = _dumped[id].pop();
                        df.__dumped = false;
                        delete df.__dumped;
                }
                return ret;
        }
        private static var _dumped:Array;
}

En prévision, pourquoi pas de pouvoir retrouver l'héritage d'une classe, comme l'a suggéré ekameleon dans le premier post de cette classe ?

::Télécharger Debug 0.2::

Je continue l'extension de classes natives de Flash pour leur attribuer le modêle évenementiel de EventDispatcher. J'en suis venu à me pencher sur la classe EventDispatcher elle-même, et j'ai découvert quelques tips, que tout le monde ne connaît pas forcément...

1. INITIALISATION
Une méthode toute simple consiste à déclarer les trois méthodes principales, et d'appeler ensuite la méthode statique 'initialize' qui va s'occuper de décorer le prototype de notre classe. A la base, c'est même dans le constructeur que l'on initialise l'instance, mais dans la classe ca fait plus mieux. En gros, on retrouve le même code un peu partout, excepté le nom de la classe qui change. import mx.events.EventDispatcher;
class EventSource {
        public var addEventListener:Function;
        public var removeEventListener:Function;
        private var dispatchEvent:Function;
        private static var __initEvent = EventDispatcher.initialize(EventSource.prototype);
} Il faut bien avouer que à la pratique, au bout d'un moment, ca devient assez lourd de toujours retaper la même chose. Un #include serait bien pratique, mais étant donné que le nom de la classe change à chaque fois, cela obligerait à laisser le initialize() dans le code de la classe. J'ai donc utilisé une autre méthode :// fichier "initEvent.as"
private static var __dispatcher:Function = mx.events.EventDispatcher;
public function addEventListener(e:String, o) {
  __dispatcher.prototype.addEventListener.apply(this, arguments);
}
public function removeEventListener(e:String, o) {
  __dispatcher.prototype.removeEventListener.apply(this, arguments);
}
private function dispatchEvent(o) {
  __dispatcher.prototype.dispatchEvent.apply(this, arguments);
}
private function dispatchQueue(q, o) {
 __dispatcher.prototype.dispatchQueue.apply(this, arguments);
}
// fin "initEvent.as"

// fichier "EventSource.as"
class EventSource {
        #include "initEvent.as"
} La méthode dispatchQueue() n'est jamais utilisée en général, excepté par dispatchEvent(), mais elle a besoin d'être là pour faire fonctionner le tout... Bon, je veux bien concevoir que c'est pas trés académique d'utiliser les prototypes. Mais en tout cas, ca fonctionne plutôt bien, et ca me permet de chager de "dispatcher" facilement. Par exemple, si je préfère utiliser GDispatcher, il me suffit de changer la première ligne de mon fichier, et toutes les classes qui l'utilisent seront mises à jour à la compilation! Et si jamais, j'ai un besoin réellement spécifique, il me suffit de copier/coller le code directement dans la classe. Cela peut même éventuellement me permettre de rajouter un typage quelqconque a mes paramètres, ou d'afficher des infos de debug, etc... 2. HANDLER INTERNE La classe EventDispatcher permet nativement de créer un handler interne qui va intercepter les évenements diffusés. Il suffit pour cela de créer une méthode qui s'appelle <nomEvenement>Handler(). Ca permet d'éviter d'inscrire une instance comme son propre écouteur :// Sans handler interne
class EventSource {
        #include "initEvent.as"
        function EventSource() {
           this.addEventListener("onEvent", this);
        }
        private function onEvent(o) {
           trace(o.type + " event dispatched");
        }
}
// Avec handler interne
class EventSource {
        #include "initEvent.as"
        function EventSource() { }
        private function onEventHandler(o) {
           trace(o.type