Bla bla blog

Aller au contenu | Aller au menu | Aller à la recherche

mardi 31 mai 2011

Initialisation graphique et FlexEvent

L'initialisation graphique des applications Flex/AS3 est le moment où l'on détermine la taille idéale de tous vos composants et containeurs pour qu'ils puissent tous être affichés, ou consultables via une scollbar le cas échéant si on manque de place.

Une initilisation en trois phases

1. Une phase d'initilisation de tous les composants graphiques en leur affectant toutes leurs propriétés. Cette phase part de l'élément le plus externe <s:Application> vers les éléments feuilles.

2. Une phase de mesure en partant des éléments feuilles vers les conteneurs de plus haut niveau. Ainsi, sauf contraintes explicites, la taille d'un conteneur dépendra de son contenu.

3. Une phase de disposition qui, forte des deux premières phases, sera capable de déterminer les positionnements précis de chacun des éléments graphiques.

Tout ceci est automatiquement géré par le framwork flex !

Les événements en présence

Comme toute cette initialisation est gérée automatiquement par le Framework, ce dernier notifie l'application via des événements de type FlexEvent. Ainsi le développeur peut savoir où on en est de ces trois phases. Il sera possible pour cela d'écouter des sources d'événements différents sur nos composants graphiques.

Pour la phase 1 : preinitialize Pour la phase 2 : initialialize et contentCreationComplete (disponible uniquement sur Application) Pour la phase 3 : creationComplete, updateComplete et applicationComplete (disponible uniquement sur Application)

Un exemple pour illustrer le tout

Prenons une application avec un Panel dans lequel on place 2 boutons et pour chacun de ces éléments, nous nous mettons à l'écoute des événements comme suit :

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
                           xmlns:s="library://ns.adobe.com/flex/spark" 
                           xmlns:mx="library://ns.adobe.com/flex/mx" 
                           minWidth="955" minHeight="600"
                           preinitialize="common(event,'Application')"
                           initialize="common(event,'Application')"
                           contentCreationComplete="common(event,'Application')"
                           creationComplete="common(event,'Application')"
                           applicationComplete="common(event,'Application')"
                           updateComplete="common(event,'Application')">
        
        <fx:Script>
                <![CDATA[
                        import mx.events.FlexEvent;
                        
                        private function common(event:FlexEvent,comp:String):void{
                                trace(event.type.toString()+"\t"+comp);
                        }

                ]]>
        </fx:Script>
        
        <s:Panel preinitialize="common(event,'Panel')"
                         initialize="common(event,'Panel')"
                         creationComplete="common(event,'Panel')"
                         updateComplete="common(event,'Panel')">
                
                <s:Button preinitialize="common(event,'Button1')"
                                  initialize="common(event,'Button1')"
                                  creationComplete="common(event,'Button1')"
                                  updateComplete="common(event,'Button1')"/>
                
                <s:Button preinitialize="common(event,'Button2')"
                                  initialize="common(event,'Button2')"
                                  creationComplete="common(event,'Button2')"
                                  updateComplete="common(event,'Button2')"/>
        </s:Panel>

</s:Application>

Nous obtenons le résultat suivant sur la console :

preinitialize   Application
preinitialize   Panel
preinitialize   Button1
initialize      Button1

preinitialize   Button2
initialize      Button2

initialize      Panel
contentCreationComplete Application
initialize      Application

creationComplete        Button1
updateComplete  Button1

creationComplete        Button2
updateComplete  Button2

creationComplete        Panel
updateComplete  Panel

creationComplete        Application
applicationComplete     Application
updateComplete  Application

mercredi 2 juin 2010

FXG vs SVG

Le langage FXG (Flash Xml Graphics) permet via des primitives (rectangle, cercle, ligne...) de définir des formes (composants) statiques ou dynamiques directement utilisables à l'intérieur d'une application Flex par exemple.

Mais pourquoi avoir défini un nouveau langage, alors que le langage SVG, qui plus est un standard, aurait très bien fait l'affaire.

L'article suivant nous donne quelques explications.

jeudi 11 mars 2010

Propagation d'événements depuis une popup

En Flex (ActionScript), comme dans tous les langages compatibles EcmaScript, lorsqu'un événement est émis depuis un composant, il va être propager entre différents objets, en suivant trois phases : capture, target et bubbling.

Imaginons l'événement clic sur un bouton, durant la phase de capture cet événement va traverser tous les composants et conteneurs parents du bouton en commençant par l'objet application avant d'atteindre le composant émetteur de l'événement. La phase "target", est justement la phase au cours de laquelle l'événement a atteint son émetteur. Enfin la phase de "bubbling" à renvoyer l'événement vers l'objet application en lui faisant prendre le chemin inverse de la phase de capture. Vous trouverez un certain nombre d'exemple dans cet article de la livedoc d'Adobe.

Ce mécanisme est très pratique car il me permet de factoriser des comportements identiques entre différents composants. L'exemple classique est celui d'un conteneur avec différents composants sur lesquels on souhaite effectuer des opération de drag&drop, plutôt que d'implémenter ce comportement identique sur chaque composant, il sera codé au niveau du conteneur dans un listeneur (handler) abonné au bons types d'événements.

Et les popups alors ??

Les popups sont créées via PopupManager.createPopup() et s'intègrent de la manière suivante dans l'arbre des objets flex : Graph propagation popups

Du coup, on comprend en regardant ce graphique que les événements ne remontent pas vers l'objet application mais directement vers l'objet SystemManager. Pour avoir un comportement factorisé pour toutes les popups, voire pour l'application, il suffira d'effectuer l'abonnement directement sur l'objet SystemManager comme suit :

Application.application.systemManager.addEventListener(...)

mercredi 27 janvier 2010

Comment embarquer une police dans une application Flex

Ayant eu le problème récemment, je vous conseille cet excellent article en français sur le sujet.

Pour résumer, il suffit de demander le chargement du fichier .ttf à la compilation de votre application tout en lui associant un nom logique. Ce nom logique vous permettra de désigner votre nouvelle police lorsque vous souhaiterez l'associer à un composant via la propriété css fontFamilly par exemple.

<mx:Style>
        global {
            fontFamily: chollSanReg;
        }
        </mx:Style>
        <mx:Script>
                <![CDATA[
                        [Embed(source="assets/fonts/ChollSanReg.ttf", fontName="chollSanReg")]
                        private var _chollSanReg:Class;
                ]]>
        </mx:Script>

Il est très intéressant d'embarquer vos propres polices dans vos applications Flex, car mis à part le fait que swf final est un peut plus lourd, si vous effectuez des rotation sur votre composant le texte avec votre police continuera d'apparaître, les effets de transparence (alpha) fonctionnent sur les polices embarquées et vous obtenez une meilleure définition lorsque vous zoomez sur votre texte.

dimanche 10 janvier 2010

Une première approche de Catalyst

Suite à une présentation de Catalyst faite par Michael Chaize au mois de décembre, j'ai eu envie de creuser ce nouvel outil qui fera sa sortie au premier semestre 2010.

L'idée de cet outil est de faire la jonction entre les équipes web design équipées de Illustrator, Photoshop et autre Gimp (oops) et les développeurs plutôt orientés flex et les technologies côté serveur (Java, Php, Coldfusion, etc.).

Personnellement, je trouve que ce nouvel outil remplit pleinement sa tâche avec plusieurs workflows possibles:

  1. j'intègre les fichiers .psd ou .ai fournis par les web designer pour définir tous les composants de base (bouton, scroll, etc.) de mon application et leurs interactions, et ainsi présenter une véritable maquette à mon client. Bien entendu le flexeur pourra reprendre ce projet (.fxp) pour ajouter toutes les échanges avec le serveur ou certaines interactions plus poussées.
  2. je définis rapidement l'organisation et toutes les interactions clientes de mon application avec des composants "wireframe" (sans mise en forme). Le client valide ces interactions, les équipes de web design et de développement peuvent alors travailler en parallèle. L'intégration des composants mis en forme pourra se faire ultérieurement, lorsque les designers auront terminer la personnalisation des composants. L'intégration reste à tester sur de projet de grande ampleur, mais Adobe travaille sur la possibilité de gérer les versions et ainsi facilité intégrations et itérations... à suivre donc
  3. enfin la possibilité de se faire une bibliothèque de composants personnalisés directement intégrables dans un projet flex

Attention les composants définis dans Catalyst ne pourront être utilisé que dans Flex 4.

Pour me faire une petite idée, je suis parti d'une image de l'Iphone, mon objectif étant de parvenir à recréer les interactions rapidement.

Vous pouvez vous faire une idée du résultat à l'adresse suivante : Iphone catalyst

Mon retour est que cet outil en version Beta est très agréable à prendre en main, pour obtenir ce résultat, il m'a fallu 1 journée en ne connaissant rien au départ (et en devant produire le fichier psd ce qui est moin d'être évident pour moi). Le seul inconvénient est qu'il est un peu gourmand en mémoire pour le moment et que je ne suis pas parvenu a créer les mouvement de drag&drop pour faire défiler le menu de l'Iphone, mais c'est peut-être par méconnaissance de ma part... Pour info c'est d'ailleurs pour cette raison que j'ai ajouté une barre de défilement en 3 clics.

L'étape suivante de cette petite démo, consisterait à l'intégrer dans flash builder (ex flex builder) pour pouvoir générer le contenu du menu, et l'horloge du téléphone... peut-être dans un autre billet !

jeudi 5 février 2009

Nouveautés TweenLite/Max V10

TweenLite et TweenMax sont deux librairies écrites en ActionScript et proposées par GreenSock. Ces deux librairies permettent d'effectuer des déplacements, transformations et autres rotations à vos objets graphiques à moindre frais et sans avoir besoin de réinventer la roue. Certains effets sont assez impressionnants et surtout contrairement à d'autres librairies les performances sont au rendez-vous.

TweenLite vs TweenMax

TweenLite correspond à un sous-ensemble de TweenMax, on retrouve dans cette librairie la classe TweenLite qui dispose d'un certain nombre de méthodes static pour effectuer des opérations graphiques : déplacement, changement de couleur.

Pour vous faire une meilleure idée, vous trouverez ci-dessous cette excellente application mise à disposition par GreenSock. Vous pourrez ainsi évaluer les fonctionnalités proposées par chacune des librairies, et voir des exemples de code.

Nouveautés de la version 10

La sortie de la Version 10 le 31/01/2009 est l'occasion de faire un point sur les nouveautés

La principale nouveautés vient déjà de l'organisation de la librairie, dans les précédentes versions il fallait choisir entre TweenLite ou TweenMax, désormais il est possible de récupérer TweenLite avec tel plugin supplémentaire de TweenMax. Le développeur a ainsi le loisir de composer sa propre librairie, de manière à embarquer dans son livrable que ce dont il a besoin.

on annonce une rapidité accrue de 40% dans cette nouvelle version.

De nombreuses nouvelles fonctions, parmi lesquels :

  1. les frameLabel équivalent des goto, mais sur la timeline flash
  2. setSize pour redimensionner facilement un objet graphique
  3. la possibilité de faire des transpositions en précisant l'origine avec TransformAroundPoint et TransformAroundCenter
  4. des rotations en 3D en précisant le ou les axes ainsi que le sens
  5. etc...
Pour plus d'informations sur ces nouveautés, rendez-vous sur le site de GreenSock

mardi 3 février 2009

Tween power

En ActionScript les classes Tween permettent quelques actions de base pour effectuer des animations, rotations et autres déplacement d'objets graphiques. Elles sont natives, mais bien souvent remplacées pour des raisons de performances par d'autres librairies comme : Tweener, TweenLite, TweenMax, ZigoEngine(Fuse), Twease, HydroTween, gTween, Tweensy, etc.

Concernant les performances entre ces différentes librairies, un comparatif nous est proposé ici par GreenSock. Ce comparatif nous montre que les librairies TweenLite et TweenMax s'en sortent plutôt bien par rapport aux autres.

Pratique d'ActionScript 3

Initialement prévu aux éditions O'reilly, ce livre ne sortira jamais sous ce format pour des raisons financières. Toutefois l'auteur, Thibault Imbert, met à disposition cet excellent bouquin sous licence "Creative Commons". Loin des mauvaises traductions, ce livre permet aussi bien au développeur débutant en ActionScript qu'au développeur AS2 de trouver une mine d'information.

Un grand bravo à Thibault Imbert pour ce petit joyau.

Pour plus d'information ou télécharger l'oeuvre, c'est ici