Etant donné l'émulsion de la blogosphère Flash, ce post ne vous apprendra rien. Vraisemblablement, le Saint Graal des développeurs AS s'apprête à pointer le bout de son nez, j'ai nommé : ActionScript 3! Mike Chambers a eu beau nous certifier durant le FlashFestival que promis, juré, craché aucune version 3 de l'AS n'était en préparation, il est là quand-même...

Cette nouvelle version du langage est associée à la plate-forme Flex 2 et à une version 8.5 du player, mais il reste encore assez compliqué de comprendre sous quelle forme...

Tout d'abord, voyons ce que propose l'AS3 :

• Des meilleures performances, grâce à une nouvelle machine virtuelle. Le player 8.5 verra donc cohabiter deux machines virtuelles, augmentant ainsi son poids. Bon, on va pas râler non plus, avec nos connexions ADSL pour la plupart, on peut bien attendre quelques secondes de plus pour avoir la compatibilité ascendante avec AS1/2...
  
• Un environnement de développement basé sur Eclipse, anciennement "code-nommé" Zorn. Un vrai rien que pour les codeurs et tout, et tout...
  
• La norme ECMAScript respectée à la lettre. On va pouvoir faire des private/protected, et tout le toutim...
  
• Le XML supporté nativement. Ca c'est cool, mais j'ai pas trop compris ce qui changeait (pitet' parce que je n'ai pas regardé ce qu'est l'E4X :$)
  
• A priori (mais j'ai pas non plus tout décortiqué), une structure du framework complètement revue. Reste à voir ce que ça va donner. Personnellement, j'espère qu'on aura enfin le droit à un new MovieClip();... J'espère aussi que le typage par interfaces a été plus largement utilisé...
  
• Ma "top feature" à moi, la gestion des sockets binaires et des expressions régulières (rationnelles pour les puristes)! Les deux combinés vont pouvoir donner naissance à des serveurs optimisés à mort au niveau du poids des données transférées dans le cadre d'une connexion socket.
  
• Et plein d'autres trucs qu'ils sont super trop bien...

Par contre, la disponibilité du langage reste assez floue... Je n'ai toujours pas bien compris comment avec quels outils on va bien pouvoir code. :\ On parle d'une version 8.5 de l'IDE Flash, alors que Mike Chambers n'annonce sa dispo sur FlashCoders que dans une version 9 dont la période de sortie est floue, ce qui fait que je ne comprends pas vraiment comment l'on va bien pouvoir harmoniser les numéros de version du player et de l'IDE... Moi, je me rangerais plus du côté de quelques commentaires qui disent qu'ils auraient mieux fait de laisser l'AS3 dans l'IDE Flash (ben oui, on a vu qu'il y était dans la démo 8ball de Mike au FlashFestival :P), quitte à sortir la version 8 un peu plus tard, plutôt que de l'enlever à l'arrache pour paumer un peu tout le monde...
On parle aussi de compilation AS3 depuis Zorn via du MXML qui génèrera du SWF, mais aucune compatibilité AS2/1, merci pour ceux qui voulaient en faire encore un peu... Bref, c'est un peu la panade à ce niveau là, et si quelqu'un pouvait éclairer tout le monde en réunissant des infos CLAIRES (outils, versions, utilisation, et pourquoi pas dates?) concernant les outils de développement à venir, ça devrait faire plaisir à pas mal de monde je pense...

En attendant le 17 Octobre pour une version alpha, il ne nous reste qu'à ronger notre frein...

Il existe la possibilité dans Windows XP de minimiser la présence de IE pour favoriser celle de navigateurs alternatifs (mettons Firefox par exemple :mrgreen:). Par exemple en changeant le navigateur par défaut, puis en désactivant l'accés à IE dans la configuration des programmes par défaut, présente depuis le SP1.

Seulement, tous les softs ne tiennent pas forcément compte de cela, et forcent l'utilisation de IE. Et quelle déception de voir que Flash est de ceux-là. Allez dans l'aide, et cliquez sur "View comments on LiveDocs"... C'est bien le navigateur Microsoftien qui s'ouvre, quel que soit votre configuration... :\

Aprés quelques légères heures passées dans les différents packages de Flash 8, voici mes premières impressions sur la partie framework. Je n'ai encore rien compilé pour l'instant, alors je peux sans doute faire pas mal d'erreurs...

• SEPY ne compile plus dans l'IDE Flash sur un CTRL+ENTREE :\ (mais bon, pas la faute a Macromedia ca quand-même :))
  
• De bonnes idées, telles que les classes Point, Rectangle et Matrix en intrinsic. Il va quand-même falloir songer a les étendre pour avoir plus de possibilités...
  
• La classe Matrix qui me décoit pas mal : uniquement dédiée aux transformations 2D, il est impossible d'accéder aux trois données du bas. A moins qu'il soit possible de hacker tout cas avec des ASSetPropFlags ou autre... :o L'idéal aurait été une classe Matrix "de base" et une classe TransformMatrix.
  
• La classe Rectangle présente pas mal de fonctionnalités sympas. L'avoir en intrinsic permet d'obtenir des performances appréciables. A priori, les développeurs de jeux vont s'en donner à coeur joie...
  
• La classe Color est deprecated... j'en fais quoi de ma classe SuperColor moi alors? Bon, je vais devoir effectuer un bon refactoring moi...
  
• Cool la classe Transform! Pouvoir appliquer tout un ensemble de transformations d'un coup, c'est bien pratique. Reste a créer des propriétés virtuelles pour pouvoir faire des Tween dessus!
  
• Je ne me suis pas encore penché sur la manipulation de Bitmaps, mais ca promet...
  
• Une feature pas vraiment mise en avant est pourtnant bien pratique. Il s'agit de la scale9Grid. En gros, ca permet de redimensionner un clip sans déformer les bords en le divisant en 9 parties (bon, je sais, c'est un gros raccourci :$). Et tout ca, accessible depuis l'IDE ou depuis ActionScript.
  
• L'apparition de la méthode clone() dans les nouvelles classes, ca c'est cool!
  
• L'évenement onHTTPStatus est bien pratique pour les LoadVars et autres XML. Par contre, a priori je n'ai pas vu de possibilité d'interrompre un transfert... :o

A priori, tout ca se présente trés bien donc.

Aprés une loooooongue reflexion, et également un petit coup de pouce de mon employeur, je propose dorénavant mes services en tant que développeur, consultant ou formateur en développement web, principalement (voire exclusivement) concernant Flash et PHP. Cette nouvelle direction dans ma vie professionnelle s'accompagne d'un mini-site sur LAlex.com.

En effet, je dispose dorénavant au sein de mon entreprise de toute la lattitude nécessaire pour travailler comme freelance. Je gère l'ensemble de mes prestations, de la commande à la facturation, et la société qui m'emploie se contente uniquement d'apposer son nom sur la facture. Et qui plus est, je travaille aux horaires de bureau (entre autres :P), ce qui fait que je peux me consacrer à plein temps aux projets qui me sont confiés, assurant ainsi des conditions de travail optimales (ce qui ne peut qu'être bénéfique à la qualité du travail fourni), et des délais "normaux".

Bref, maintenant je n'ai plus à refuser les projets qu'on me propose! Ce que j'aimerais maintenant, c'est trouver des projets techniquement ambitieux dans lesquels je puisse vraiment me lâcher!

J'en profite pour faire un petit clin d'oeil à un collègue graphiste, qui s'est lancé lui aussi il y a quelques mois, et a fait un zouli site. Nous travaillons en binôme, donc s'il y a besoin d'une vraie compétence en conception graphique (évidemment, si je suis tout seul, ca ira pas loin :$), c'est possible aussi!

Je croise les doigts...

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

Le fait de pouvoir intercepter un évenement de type double clic a longtemps été demandé pour les boutons Flash. En attendant, je fais comme tout le monde, je me débrouille... et voici comment je fais dans le cadre d'une classe héritant de MovieClip.

class DblClickMovieClip extends MovieClip {
        // Interval called if second click is too late
        private var _itv:Number;
        // Amount of succesive clicks
        private var _click:Number = 0;
        // onPress event
        private function onPress() {
                dblClick();
        }
        // Check if 2 clicks were made in the given timelapse
        private function dblClick() {
                if (++_click == 2) {
                        _click = 0;
                        onDblClick();
                } else {
                        // Double click timelapse can be set here
                        _itv = setInterval(this, "clickTimeout", 250);
                }
        }
        // Init clicks
        private function clickTimeout() {
                clearInterval(_itv);
                _click = 0;
        }
        // Called if double click
        private function onDblClick() {
                trace("Double click");
        }
}
Bien évidemment, cette méthode est adaptable si on ne veut pas que tout le clip soit clicable... Je pensais d'ailleurs implémenter ca par la suite sous forme de décorateur d'un clip...

Il doit y avoir des centaines de méthodes pour arriver au même résultat, alors si quelqu'un en voit une meilleure, qu'il n'hésite pas! Et pour finir, ne désespérons pas de l'avoir un jour en natif, il ne nous aura fallu que 4 versions pour avoir l'upload de fichiers !

C'était kitch à mort, Macromedia l'a fait : l'annonce de Flash 8 le 8/8 : http://www.macromedia.com/software/flash/flashpro/

Vous trouverez un petit tour assez instructif sur les nouvelles fonctionnalités. Un coup de coeur pour le paramétrage des interpolations, et pour la possibilité de diffuser des évenements à certains points (cue points) d'une vidéo!

Pour le reste, no comment tant que j'ai pas la trial dans les mains...

Maintenant qu'on est rassuré (enfin déçu) sur la non-évolution de l'Actionscript dans la prochaine mouture de Flash, il devient urgent si l'on est développeur de RIA (fashion non ?) de trouver une alternative aux composants V2 de Macromedia. En effet, il faut bien avouer qu'ils sont lourds et buggués, mais quand-même bien pratiques !

Histoire de ne pas réinventer la roue en les développant soi-même (surtout que c'est quand-même un gros morceau), j'ai essayé de faire un petit tour d'horizon de ce qui existait et qui semblait sérieux.

Le seul package dont je peux vraiment parler, étant donné que c'est le seul "essayable", est celui des SMX Components. Déployés sur le site de la BBC (a ce qu'il paraît, je les ai jamais trouvés), ils semblent fiables et performants, mais assez "brouillons" à mon avis... Il manque aussi quelques composants, comme le Tree, Accordion, Radio, Date, etc... Et puis quand je dis "essayé", c'est en dilletante, jamais au coeur d'une véritable application...

Les BitComponents de BJC, aujourd'hui rachetés pas FlashLoaded... Il n'est pas possible de les essayer malheureusement, mais sur le papier ils semblent trés complets. Eprouvés, leur réputation n'est plus à faire... En plus, 99$ c'est pas non plus le bout du monde !

Les XPComponents, dont une nouvelle version vient de voir le jour... Un package trés complet, et sourtout basé sur des interfaces, ce qui permet une personnalisation avancée. Comme les précédents, trés bien sur le papier, mais impossible de les essayer... Pour 349$, vous avez quand-même les sources

Et l'arlésienne : GLIC, dorénavant les mCOM On les attend, on les attend, et toujours rien. Evidemment, quand on sait qui est derrière, on se dit dit que ca vaut surement le coup. Reste à voir ce que ca va donner, et surtout les conditions de licence et de prix... :o

Pour conclure, je dirais que pour acheter un pack de composants comme ceux cités ci-dessus, la moindre des choses serait de pouvoir les essayer. Evidemment, difficile d'implémenter un système de "Trial" pour des composants, mais quand on développe de véritables applications, il est délicat d'investir si l'on est pas sûr que les composants répondront à notre besoin. :\

En restant sur le papier, personnellement je serais séduit par les BitComponents : pas cher, complets, et esthétiquement trés convenables.

Si vous connaissez d'autres sets de composants, ou que vous avez essayé un des sets cités ici, n'hésitez pas à le signaler dans les commentaires...

Je suppose que la plupart des codeurs ont leur classe de debug. Voici la mienne, a peine commencée. Il s'agit uniquement d'un dump d'un objet. La méthode un objet recursivement pour afficher l'ensemble de ses propriétés. Il gère également le fait qu'on ait pu mettre le nom de la classe dans une variable statique (par défaut __className).

/**
* Debug
* @version 0.1
* @package com.lalex.utils
*
* @author <a href="http://www.lalex.com/">LAlex</a>
* @since 2005-07-19
*/
class com.lalex.utils.Debug {
        /**
        * Property used to store class names
        */
        public static var classNameProperty:String = "__className";
        /**
        * Trace an object detailled content
        * @param o Object to display
        */
        public static function dump(o) {
                _global.trace(dumpToString(o));
        }
        /**
        * Return a string containing the object content. Recursive method
        * @param o Target object
        * @param d Depth. Used to generate tabs
        */
        private static function dumpToString(o, d:Number):String {
                d = d ? d : 0;
                var dp:Number = d;