Si vous voyez ce post, cela veut dire que vous venez de rejoindre le nouveau serveur. Vous pouvez détacher vos ceintures et vous relaxer jusqu'à l'arret de l'appareil ...

Bref, vous pouvez vous jeter à nouveau sur les commentaires, et apprécier ce nouvel hébergement.

A ce sujet, l'interface d'administration du serveur est Plesk 7 : un nombre incroyable d'options configurables, et une interface assez esthétique en plus ce qui ne gache rien ! Un coup de chapeau à cette application donc !

Plus de deux mois après l'introduction sur cette série d'articles sur les pratiques de programmation en PHP, voici le premier opus de présentation.

Conventions

Afin de réduire les lourdeurs du texte, je parlerai de BDD pour dire "Base de Données", et de POO pour "Programmation Orientée Objet". Les autres abréviations seront précisées au début de chaque article.

La plupart des pratiques qui seront abordées seront valables pour PHP4, et les spécificités de PHP5 qui seront abordées seront différenciées visiblement dans les articles. Le moteur de BDD utilisé sera MySQL, le plus fréquemment utilisé avec PHP (bien que PHP5 propose maintenant une intégration avec SQLite).

Avant de commencer

La règle d'or qui vous suivra durant toute votre lecture sera : "NE PAS REPETER PLUSIEURS FOIS LA MEME CHOSE !!!". Si vous ne voyez pas déjà à quoi je fais allusion, ne vous inquiétez pas, vous aurez l'occasion de la revoir très souvent dans les différents articles qui suivront. En effet, si la règle reste la même, elle peut prendre bien des formes différentes selon la situation.

Je vous rappelle à nouveau qu'il s'agit là de mes pratiques, et aucunement d'une méthode universelle à suivre absolument. Seulement cela peut poser à mon avis de bonnes bases pour un code efficace et clair : en tout cas, ça marche pour moi !

Et maintenant ?

Voici un petit aperçu des domaines qui seront abordés. Cette liste est susceptible d'évoluer durant la rédaction en fonction des besoin et remarques qui seront exprimés dans les commentaires ou de mes envies :

• La base de données
  
• L'organisation des fichiers de travail et du code
  
• Ergonomie et astuces diverses
  
• La POO

La première partie pratique que nous aborderons est donc la base de données ... a très bientôt !

Colin Moock s'est imposé depuis son livre ActionScript for Flash MX : the Definitive Guide comme ayant écris l'ouvrage de référence des programmeurs Flash. Aujourd'hui, il remet le couvert et se penche sur le "nouveau" langage de Macromedia, introduit dans Flash MX 2004, avec Essential ActionScript 2.0.

Loin de remplacer son précédant ouvrage, cette nouvelle référence se veut comme étant un complément de celui-ci. En effet, alors que le premier était une liste quasi-exhaustive de l'AS1, EAS2 s'attaque à la philosophie de développement complètement revue d'AS2, du fait de son orientation objet. Il s'adresse donc en bloc aux programmeurs AS1 intermédiaires, ainsi qu'aux développeurs objets issus de langages plus "traditionnels" tels que Java ou C++, et aux programmeurs AS2 intermédiaires et même confirmés.

La première partie du livre aborde la syntaxe AS2. Mêlant habilement l'initiation à la programmation objet, et la description des instructions introduites par la nouvelle mouture d'ActionScript, cette partie fourni au futur programmeur AS2 tous les outils nécessaires à ses premiers développements. N'oubliant pas d'aller au fond des choses, Colin Moock décortique chaque instruction à l'extrême, soulignant les particularités des nombreuses situations qui peuvent se présenter au codeur face aux instructions AS2.
Parfois répétitif dans son discours, mais jamais rébarbatif, il mets systématiquement le doigt sur les erreurs que l'on fait fréquemment lorsque l'on aborde l'AS2, et souligne les avantages indéniables qu'apporte ce nouveau langage, mais aussi cette nouvelle façon d'aborder le développement dans Flash.
Non content de donner une explication théorique exhaustive des syntaxes de base, des exemples concrets sont apportés avant d’aborder chaque nouvelle notion importante, nous guidant ainsi au travers du développement d'une classe ImageViewer, dans laquelle sont utilisées les notions précédemment abordées de manière plus formelle.

La deuxième partie aborde les méthodes à utiliser lors du développement d'application. L'auteur nous y présente tout d'abord sa méthode de travail "de base" notamment en terme de hiérarchie des dossiers et documents. Sans être révolutionnaire, elle a le mérite d'être simple, claire et efficace. Si vous n'avez pas déjà vos propres habitudes de développement objet, je dirais tout simplement que l'essayer c'est l'adopter, et si vous les avez déjà, vous pourrez ainsi les confronter à celles qui sont données dans ce chapitre.
Les chapitres suivant nous emmènent vers la programmation "visuelle", tout d'abord en abordant les composants et leur utilisation, en exposant notamment leur intégration à une application concrète de convertisseur de devises, puis en consacrant un chapitre entier à l'héritage de MovieClip, nous en dévoilant ainsi toutes ses subtilités, et également les aspects à prendre en compte pour effectuer un choix entre l'héritage et la composition avec MovieClip.
Cette partie se finit en décortiquant les différents moyens mis à notre disposition pour distribuer un code, que ce soit en OpenSource ou sans mettre les fichiers sources à dispositions des utilisateurs, en énonçant clairement les avantages, inconvénients et difficultés de chacune des méthodes.

La troisième partie se penche sur 4 Design Patterns, parmi les plus utilisés dans Flash que sont l'Observer, le Singleton, le Model-View-Controller (MVC) et la Délégation d'événements. Plus qu'une description approfondie de ces patterns, il s'agit plutôt dans cette partie de montrer leur utilité au sein d'applications AS2, ainsi que leur implémentation au sein d'exemple toujours aussi concrets.

Je ne peux que supposer la réaction des différentes catégories de lecteurs visées par ce livre :

• Pour les développeurs AS1, il introduit en douceur mais également en profondeur toutes les subtilités de AS2. Etant déjà convaincu, je ne peux que suggérer, mais je dirais que ce livre peut réussir à convaincre ceux qui sont encore réfractaire à l'AS2, en soulignant tous les avantages que cela emmène, que ce soit en terme d'organisation du code, mais aussi d'aide au développement prodiguée par les erreurs de compilation. Un coup de chapeau concernant le détail exhaustif des différentes possibilités qui existent quand on surcharge une méthode, et concernant le chapitre sur le gestion d'erreurs qui est un bijou de précision qui sont tout deux des bijoux de précision, allant vraiment au fond des choses.
  
• Pour les développeurs Objet découvrant l'AS2, en plus de décrire précisément les différences avec des langages reconnus tels que Java, l'ouvrage s'attache à faire découvrir la philosophie de développement à aborder avec Flash, qui diffère de par son orientation clairement graphique. Pour ceux qui sont déjà à l'aise avec les Design Patterns, il s'agit aussi de voir de bonnes implémentations AS2, pour ainsi se plonger dans le langage.
  
• Pour les développeurs AS2, qu'ils soient intermédiaires ou aguerris, il s'agit là d'une revue de détail, répondant la plupart du temps aux questions que l'on peut se poser sur quelques finesses du langage. Si l'on peut finir le livre en pensant ne pas avoir appris énormément par rapport à ce que l'on savait déjà, le simple fait de se remettre à programmer après cette lecture change la manière dont on voit le code. En gros, pour moi, j'ai vraiment l'impression que les qualités pédagogiques de l'auteur ont clarifié certaines notions qui m'étaient connues jusque là, mais peut-être un peu embrouillées !

En conclusion, je dirais que Colin Moock nous offre un nouvel ouvrage de référence, qui saura satisfaire de par son contenu riche et détaillé tous les développeurs accomplis ou en devenir. Véritable fondation des connaissances à posséder en ActionScript 2.0, il s'avère la rampe de lancement idéale pour aller encore plus loin dans la Programmation Orientée Objet avec AS2.

Pour finir, je vous conseille de lire suite à ce livre celui sur les Design Patterns par le Gang Of Four, que j'ai moi-même lu sur les conseil de Francis BOURRE, et qui est d'ailleurs cités par Colin Moock dans la troisième partie de l'ouvrage. Il s'agit là d'une véritable mine d'or sur les DP.

Pour continuer dans la série des 0.1, voici aujourd'hui une classe que je termine tout juste, servant à gérer le positionnement et la taille de clips dans des animations Flash plein écran. En effet, alors qu'il est maintenant possible de créer des site Flash occupant la totalité d'une fenêtre grâce à la classe Stage, trés peu de site l'utilisent ...

J'ai donc crée ce set de classe afin de faciliter la gestion des clips dans cette situation précise. On peut ainsi décider de la position d'un clip et de son alignement sur la scène, ainsi que sa taille. Il est ainsi possible de profiter presque de la même souplesse qu'offre HTML pour des applications qui pourraient ainsi occuper la totalité de la surface de l'animation.

Voici un exemple d'utilisation:import com.lalex.stage.StageManager;
import com.lalex.movieclip.SuperClip;
var stageMgr:StageManager = StageManager.getInstance();
// Alignement en haut à gauche, sans marge, de largeur 100%, hauteur inchangée
stageMgr.addElement(new SuperClip(_root.taskbar), {align:"left,top", margin:0, size:"100%,none"});
// Aligné à droite, avec une marge (à droite) de 10px
stageMgr.addElement(new SuperClip(_root.rightMenu), {align:"right", margin:10});
// Aligné en bas avec une marge (verticale) de 5% de la hauteur de l'anim
stageMgr.addElement(new SuperClip(_root.footer), {align:"bottom", margin:"none,5%"});
Bien qu'il manque encore des fonctionnalités ou des options de positionnement, StageManager est dors et déjà utilisable, et la classe SuperClip devrait donner naissance à une fonctionnalité similaire aux méthodes de positionnement de Stéphan Guénette.

L'utilisation de la composition dans SuperClip permet ainsi de gérer des clips dont le redimensionnement devrait se faire de manière spécifique, comme des composants par exemple. Il suffirait alors de créer une classe qui implémente l'interface IClip. Bref, en créant la classe appropriée, vous pouvez gérer virtuellement tout objet qui s'affiche à l'écran.

::Télécharger StageManager.zip::

En me balandant sur l'excellent blog Quasimondo, je suis tombé sur un lien vers une librairie permettant de reproduire l'effet trés en vogue d'un livre dont on tourne les pages, fait par Ipari Grafika. Il dispose d'un foule d'options, comme la transparence, l'utilisation de zones pour tourner une page, des pages solides (typiquement la couverture d'un livre). La demonstration est assez édifiante, voire impressionante !

Vous pouvez même télécharger les sources !

On vient de me faire remarquer que la dernière version du color_toolkit de Robert PENNER permet également de gérer le contraste d'un clip. Je me suis donc empressé de rajouter ces fonctionnalités à ma classe SuperColor qui passe pour l'occasion en version 0.3.

J'en ai également profité pour modifier le nom du package : en effet, avec un nom de domaine comme www.lalex.com, il est plus logique de garder com.lalex en nom de package ... même si le coté commercial ne me plait pas vraiment ! :o

/**
 * Super Color
 * extended Color class
 *
 * -----------------------------------
 *
 * Based on <a href="http://www.robertpenner.com/">Robert PENNER</a> Color Toolkit v1.3
 *
 * Properties
 *
 *   _brightness
 *   _brightOffset
 *   _contrast
 *   _negative
 *
 *   _rgb
 *   _rgbStr
 *   _red
 *   _green
 *   _blue
 *
 *   _redPercent
 *   _greenPercent
 *   _bluePercent
 *
 *   _redOffset
 *   _greenOffset
 *   _blueOffset
 *
 * Methods
 *
 *   getTarget()
 *
 *   setRGBStr()
 *   getRGBStr()
 *   setRGB2()
 *   getRGB2()
 *   reset()
 *
 *   setBrightness()
 *   getBrightness()
 *   setBrightOffset()
 *   getBrightOffset()
 *       setContrast()
 *   getContrast()
 *
 *   getNegative()
 *   setNegative()
 *   invert()
 *
 *   setTint()
 *   getTint()
 *   setTint2()
 *   getTint2()
 *   setTintOffset()
 *   getTintOffset()
 *
 *   setRed()
 *   getRed()
 *   setGreen()
 *   getGreen()
 *   setBlue()
 *   getBlue()
 *
 *   setRedPercent()
 *   getRedPercent()
 *   setGreenPercent()
 *   getGreenPercent()
 *   setBluePercent()
 *   getBluePercent()
 *
 *   setRedOffset()
 *   getRedOffset()
 *   setGreenOffset()
 *   getGreenOffset()
 *   setBlueOffset()
 *   getBlueOffset()
 *
 * @version 0.3
 * @author <a href="http://www.lalex.com/">LAlex</a>
 * @since 19/08/2004
 */
class com.lalex.movieclip.SuperColor extends Color {
        private var _targetMC:MovieClip;
        /**
         * Constructor
         * @param clip Clip to apply the color
         */
        function SuperColor(clip:MovieClip) {
                super(clip);
                _targetMC = clip;
        }
        /**
         * Returns affected clip
         * @return Targeted MovieClip
         */
        public function getTarget():MovieClip {
                return _targetMC;
        }
                // ----------o RGB


        /**
         * Set an RGB value from an hexadecimal string
         * @param hexStr Hexadecimal value string
         */
        public function setRGBStr(hexStr:String) {
                // grab the last six characters of the string
                hexStr = hexStr.substr (-6, 6);
                setRGB (parseInt (hexStr, 16));
        }
        /**
         * Get the RGB value as a string
         * @return Hexadecimal value string
         */
        public function getRGBStr():String {
                var hexStr:String = getRGB().toString(16);
                // fill in zeroes as needed
                var toFill:Number = 6 - hexStr.length;
                while (toFill--) hexStr = "0" + hexStr;
                return hexStr.toUpperCase();
        }
        /**
         * Set red, green, and blue with normal numbers
         * @param r Red value between 0 and 255
         * @param g Greeb value between 0 and 255
         * @param b Blue value between 0 and 255
         */
        public function setRGB2(r:Number, g:Number, b:Number) {
                setRGB (r << 16 | g << 8 | b);
        } // Branden Hall - <a href="http://www.figleaf.com">www.figleaf.com</a>
        /**
         * @return Object with r, g, and b properties
         */
        public function getRGB2():Object {
                var t = getTransform();
                return {r:t.rb, g:t.gb, b:t.bb};
        }
        /**
         * Reset the color object to normal
         */
        public function reset() : Void {
                setTransform ({ra:100, ga:100, ba:100, rb:0, gb:0, bb:0});
        }


                // ----------o Brightness


        /**     
         * Brighten just like Property Inspector of MovieClip
         * @param val Brightness between -100 and 100
         */
        public function setBrightness(val:Number) {
                var trans:Object = getTransform();
                with (trans) {
                        ra = ga = ba =  100 - Math.abs(val);
                        rb = gb = bb = (val > 0) ? val * (256/100) : 0;
                }
                setTransform(trans);
        }
        /**
         * @return Brightness set with setBrightness
         * @see setBrightness
         */
        public function getBrightness():Number {
                var trans:Object = getTransform();
                with (trans) {
                        return rb ? 100 - ra : ra - 100;
                }
        }
        /**
         * Set brightness offset
         * @param val Offset between -255 and 255
         */
        public function setBrightOffset(val:Number) {
                var trans:Object = getTransform();
                with (trans) {
                        rb = gb = bb = val;
                }
                setTransform(trans);
        }
        /**
         * @return Brightness set with setBrightOffset
         * @see setBrightOffset
         */
        public function getBrightOffset():Number {
                return getTransform().rb;
        }


                // ----------o Contrast
        /**
         * Set contrast
         * @param val Percent between -100 and 100
         */
        public function setContrast(val:Number) {
                var trans:Object = {};
                trans.ra = trans.ga = trans.ba = val;
                trans.rb = trans.gb = trans.bb = 128 - (128/100 * val);
                setTransform(trans);
        }
        /**
         * @return Contrast set with setContrast
         * @see setContrast
         */
        public function getContrast():Number {
            return getTransform().ra;
        }
                // ----------o Negative and invert

        /**
         * Produce a negative image of the normal appearance
         * @param percent Between 0 and 100
         */
        public function setNegative(percent:Number) {
            var t:Object = {};
            t.ra = t.ga = t.ba = 100 - 2 * percent;
            t.rb = t.gb = t.bb = percent * (255/100);
            setTransform (t);
        }
        /**
         * @return Negative percentage
         * @see setNegative
         */
        public function getNegative():Number {
            return getTransform().rb * (100/255);
        }
        /**
         * Invert the current color values
         */
        public function invert() {
                var trans:Object = getTransform();
                with (trans) {
                        ra = -ra;
                        ga = -ga;
                        ba = -ba;
                        rb = 255 - rb;
                        gb = 255 - gb;
                        bb = 255 - bb;
                }
                setTransform (trans);
        }


                // ----------o Tint


        /**
         * Tint with a color just like Property Inspector
         * @param r Red value between 0 and 255
         * @param g Greeb value between 0 and 255
         * @param b Blue value between 0 and 255
         * @param percent Between 0 and 100
         */
        public function setTint(r:Number, g:Number, b:Number, percent:Number) {
                var ratio = percent / 100;
                var trans = {rb:r*ratio, gb:g*ratio, bb:b*ratio};
                trans.ra = trans.ga = trans.ba = 100 - percent;
                setTransform (trans);
        }
        /**
         * @return tint object containing r, g, b, and percent properties
         * @see setTint
         */
        public function getTint():Object {
                var trans:Object = getTransform();
                var tint:Object = {percent: 100 - trans.ra};
                var ratio:Number = 100 / tint.percent;
                tint.r = trans.rb * ratio;
                tint.g = trans.gb * ratio;
                tint.b = trans.bb * ratio;
                return tint;
        }
        /**
         * tint with a color - alternate approach
         * @param rgb Color number between 0 and 0xFFFFFF
         * @param percent Between 0 and 100
         */
        public function setTint2(rgb:Number, percent:Number) {
                var r:Number = (rgb >> 16) ;
                var g:Number = (rgb >> <img src="http://common.lalex.com/themes/devblog/smilies/icon_cool.gif" alt="8)" class="smiley" /> & 0xFF;
                var b:Number = rgb & 0xFF;
                var ratio:Number = percent / 100;
                var trans:Object = {rb:r*ratio, gb:g*ratio, bb:b*ratio};
                trans.ra = trans.ga = trans.ba = 100 - percent;
                setTransform (trans);
        }
        /**
         * @return a tint object containing rgb (a 0xFFFFFF number) and percent properties
         * @see setTint2
         */
        public function getTint2():Object {
                var trans:Object = getTransform();
                var tint:Object = {percent: 100 - trans.ra};
                var ratio:Number = 100 / tint.percent;
                tint.rgb = (trans.rb*ratio)<<16 | (trans.gb*ratio)<<8 | trans.bb*ratio;
                return tint;
        }


                // ----------o Tint offset


        /**
         * @param r Red value between 0 and 255
         * @param g Greeb value between 0 and 255
         * @param b Blue value between 0 and 255
         */
        public function setTintOffset(r:Number, g:Number, b:Number) {
                var trans:Object = getTransform();
                with (trans) {
                        rb = r;
                        gb = g;
                        bb = b;
                }
                setTransform (trans);
        }
        /**
         * @return Object containing r, g, b properties
         * @see setTintOffset
         */
        public function getTintOffset():Object {
                var t:Object = getTransform();
                return {r:t.rb, g:t.gb, b:t.bb};
        }


                // ----------o Color values

        /**
         * Set red value
         * @param amount Between 0 and 255
         */
        public function setRed(amount:Number) {
                var t = getTransform();
                setRGB (amount << 16 | t.gb << 8 | t.bb);
        }
        /**
         * Get red value
         * @return Value between 0 and 255
         * @see setRed
         */
        public function getRed():Number {
                return getTransform().rb;
        }
        /**
         * Set green value
         * @param amount Between 0 and 255
         */
        public function setGreen(amount:Number) {
                var t = getTransform();
                setRGB (t.rb << 16 | amount << 8 | t.bb);
        }
        /**
         * Get green value
         * @return Value between 0 and 255
         * @see setGreen
         */
        public function getGreen():Number {
                return getTransform().gb;
        }
        /**
         * Set blue value
         * @param amount Between 0 and 255
         */
        public function setBlue(amount:Number) {
                var t = getTransform();
                setRGB (t.rb << 16 | t.gb << 8 | amount);
        }
        /**
         * Get blue value
         * @return Value between 0 and 255
         * @see setBlue
         */
        public function getBlue():Number {
                return getTransform().bb;
        }


                // ----------o Color percentages

        /**
         * Set red percentage
         * @param percent Between -100 and 100
         */
        public function setRedPercent(percent:Number) {
                var trans:Object = getTransform();
                trans.ra = percent;
                setTransform (trans);
        }
        /**
         * Get red percentage
         * @return Value between -100 and 100
         * @see setRedPercent
         */
        public function getRedPercent():Number {
                return getTransform().ra;
        }
        /**
         * Set green percentage
         * @param percent Between -100 and 100
         */
        public function setGreenPercent(percent:Number) {
                var trans:Object = getTransform();
                trans.ga = percent;
                setTransform (trans);
        }
        /**
         * Get green percentage
         * @return Value between -100 and 100
         * @see setGreenPercent
         */
        public function getGreenPercent():Number {
                return getTransform().ga;
        }
        /**
         * Set blue percentage
         * @param percent Between -100 and 100
         */
        public function setBluePercent(percent:Number) {
                var trans:Object = getTransform();
                trans.ba = percent;
                setTransform (trans);
        }
        /**
         * Get blue percentage
         * @return Value between -100 and 100
         * @see setBluePercent
         */
        public function getBluePercent():Number {
                return getTransform().ba;
        }


                // ----------o Color offsets

        /**
         * Set red offset
         * @param offset Between -255 and 255
         */
        public function setRedOffset(offset:Number) {
                var trans:Object = getTransform();
                trans.rb = offset;
                setTransform (trans);
        }
        /**
         * Get red offset
         * @return Value between -255 and 255
         * @see setRedOffset
         */
        public function getRedOffset():Number {
                return getTransform().rb;
        }
        /**
         * Set green offset
         * @param offset Between -255 and 255
         */
        public function setGreenOffset(offset:Number) {
                var trans:Object = getTransform();
                trans.gb = offset;
                setTransform (trans);
        }
        /**
         * Get green offset
         * @return Value between -255 and 255
         * @see setGreenOffset
         */
        public function getGreenOffset():Number {
                return getTransform().gb;
        }
        /**
         * Set blue offset
         * @param offset Between -255 and 255
         */
        public function setBlueOffset(offset:Number) {
                var trans:Object = getTransform();
                trans.bb = offset;
                setTransform (trans);
        }
        /**
         * Get blue offset
         * @return Value between -255 and 255
         * @see setBlueOffset
         */
        public function getBlueOffset():Number {
                return getTransform().bb;
        }

                // ----------o Getter/Setter

        /**
         * RGB value
         * @type Number
         */
        function set _rgb(val:Number) {
                setRGB(val);
        }
        function get _rgb():Number {
                return getRGB();
        }
        /**
         * RGB value
         * @type String
         */
        function set _rgbStr(val:String) {
                setRGBStr(val);
        }
        function get _rgbStr():String {
                return getRGBStr();
        }
        /**
         * Brightness value
         * @type Number
         */
        function set _brightness(b:Number) {
                setBrightness(b);
        }
        function get _brightness():Number {
                return getBrightness();
        }
        /**
         * Brightness offset
         * @type Number
         */
        function set _brightOffset (b:Number) {
                setBrightOffset(b);
        }
        public function get _brightOffset():Number {
                return getBrightOffset();
        }
        /**
         * Contrast
         * @type Number
         */
        function set _contrast (c:Number) {
                setContrast(c);
        }
        public function get _contrast():Number {
                return getContrast();
        }
        /**
         * Negative percentage
         * @type Number
         */
        public function set _negative(p:Number) {
                setNegative(p);
        }
        public function get _negative():Number {
                return getNegative();
        }
        /**
         * Red value
         * @type Number
         */
        public function set _red(v:Number) {
                setRed(v);
        }
        public function get _red():Number {
                return getRed();
        }
        /**
         * Green value
         * @type Number
         */
        public function set _green(v:Number) {
                setGreen(v);
        }
        public function get _green():Number {
                return getGreen();
        }
        /**
         * Blue value
         * @type Number
         */
        public function set _blue(v:Number) {
                setBlue(v);
        }
        public function get _blue():Number {
                return getBlue();
        }
        /**
         * Red percentage
         * @type Number
         */
        public function set _redPercent(v:Number) {
                setRedPercent(v);
        }
        public function get _redPercent():Number {
                return getRedPercent();
        }
        /**
         * Green percentage
         * @type Number
         */
        public function set _greenPercent(v:Number) {
                setGreenPercent(v);
        }
        public function get _greenPercent():Number {
                return getGreenPercent();
        }
        /**
         * Blue percentage
         * @type Number
         */
        public function set _bluePercent(v:Number) {
                setBluePercent(v);
        }
        public function get _bluePercent():Number {
                return getBluePercent();
        }
        /**
         * Red offset
         * @type Number
         */
        public function set _redOffset(v:Number) {
                setRedOffset(v);
        }
        public function get _redOffset():Number {
                return getRedOffset();
        }
        /**
         * Green offset
         * @type Number
         */
        public function set _greenOffset(v:Number) {
                setGreenOffset(v);
        }
        public function get _greenOffset():Number {
                return getGreenOffset();
        }
        /**
         * Blue offset
         * @type Number
         */
        public function set _blueOffset(v:Number) {
                setBlueOffset(v);
        }
        public function get _blueOffset():Number {
                return getBlueOffset();
        }
}

::Télécharger SuperColor.zip::

Aprés de petites "vacances d'ordi" (mais seulement d'ordi, le boulot a continué), le temps de fêter les 25 ans de mes pieds, de reformater ma machine, et de nettoyer une à une les touches de mon clavier au coton-tige, je reviens donc sur la toile, et vous proposerait bientôt le premier article de ma série sur la programmation PHP/MySQL ... le temps de le réécrire car il a subit une combustion spontanée lors du formatage précédemment cité !

Je travaille également sur lecodage "from scratch" du site Fast2reply (qui ne sera jamais fini à l'heure) sans compter le Zend Contest, l'apprentissage des rudiments de Flash Communication Server MX et de Unity 2, histoire de me tenir un peu à la page sur les technologies multi-utilisateurs montantes, sans oublier de finir de lire Essential ActionScript 2.0 !

De tout ça, je pense sortir quelques billets qui je l'espère vous interesseront !

Sinon, signalons quand-même sous forme de coup de chapeau deux billets de Francis BOURRE, qui nous signale sur son blog les nouveaux-nés du blogging flash francophone, et nous gratifie d'un superbe nouvel opus de sa série sur les design patterns : le pattern Commande

Un des aspects pas pratiques de la classe Color est l'impossibilité de que l'on a de récupérer le clip ciblé par cet objet. J'ai donc un peu modifié ma classe SuperColor afin qu'elle contienne une méthode qui renvoie une référence au clip affecté par les changements de couleurs :
/**
 * Super Color
 * extended Color class
 *
 * -----------------------------------
 *
 * Based on <a href="http://www.robertpenner.com/">Robert PENNER</a> Color Toolkit v1.2
 *
 * Properties
 *
 *   _brightness
 *   _brightOffset
 *   _negative
 *
 *   _rgb
 *   _rgbStr
 *   _red
 *   _green
 *   _blue
 *
 *   _redPercent
 *   _greenPercent
 *   _bluePercent
 *
 *   _redOffset
 *   _greenOffset
 *   _blueOffset
 *
 * Methods
 *
 *   getTarget()
 *
 *   setRGBStr()
 *   getRGBStr()
 *   setRGB2()
 *   getRGB2()
 *   reset()
 *
 *   setBrightness()
 *   getBrightness()
 *   setBrightOffset()
 *   getBrightOffset()
 *
 *   setTint()
 *   getTint()
 *   setTint2()
 *   getTint2()
 *   setTintOffset()
 *   getTintOffset()
 *
 *   getNegative()
 *   setNegative()
 *   invert()
 *
 *   setRed()
 *   getRed()
 *   setGreen()
 *   getGreen()
 *   setBlue()
 *   getBlue()
 *
 *   setRedPercent()
 *   getRedPercent()
 *   setGreenPercent()
 *   getGreenPercent()
 *   setBluePercent()
 *   getBluePercent()
 *
 *   setRedOffset()
 *   getRedOffset()
 *   setGreenOffset()
 *   getGreenOffset()
 *   setBlueOffset()
 *   getBlueOffset()
 *
 * @version 0.2
 * @author <a href="http://www.lalex.com/">LAlex</a>
 * @since 05/08/2004
 */
class com.lalex.movieclip.SuperColor extends Color {
        private var _targetMC:MovieClip;
        /**
         * Constructor
         * @param clip Clip to apply the color
         */
        function SuperColor(clip:MovieClip) {
                super(clip);
                _targetMC = clip;
        }
        /**
         * Returns affected clip
         * @return Targeted MovieClip
         */
        public function getTarget():MovieClip {
                return _targetMC;
        }
                // ----------o RGB


        /**
         * Set an RGB value from an hexadecimal string
         * @param hexStr Hexadecimal value string
         */
        public function setRGBStr(hexStr:String) {
                // grab the last six characters of the string
                hexStr = hexStr.substr (-6, 6);
                setRGB (parseInt (hexStr, 16));
        }
        /**
         * Get the RGB value as a string
         * @return Hexadecimal value string
         */
        public function getRGBStr():String {
                var hexStr:String = getRGB().toString(16);
                // fill in zeroes as needed
                var toFill:Number = 6 - hexStr.length;
                while (toFill--) hexStr = "0" + hexStr;
                return hexStr.toUpperCase();
        }
        /**
         * Set red, green, and blue with normal numbers
         * @param r Red value between 0 and 255
         * @param g Greeb value between 0 and 255
         * @param b Blue value between 0 and 255
         */
        public function setRGB2(r:Number, g:Number, b:Number) {
                setRGB (r << 16 | g << 8 | b);
        } // Branden Hall - <a href="http://www.figleaf.com">www.figleaf.com</a>
        /**
         * @return Object with r, g, and b properties
         */
        public function getRGB2():Object {
                var t = getTransform();
                return {r:t.rb, g:t.gb, b:t.bb};
        }
        /**
         * Reset the color object to normal
         */
        public function reset() : Void {
                setTransform ({ra:100, ga:100, ba:100, rb:0, gb:0, bb:0});
        }


                // ----------o Brightness


        /**     
         * Brighten just like Property Inspector of MovieClip
         * @param val Brightness between -100 and 100
         */
        function setBrightness(val:Number) {
                var trans:Object = getTransform();
                with (trans) {
                        ra = ga = ba =  100 - Math.abs(val);
                        rb = gb = bb = (val > 0) ? val * (256/100) : 0;
                }
                setTransform(trans);
        }
        /**
         * @return Brightness set with setBrightness
         * @see setBrightness
         */
        function getBrightness():Number {
                var trans:Object = getTransform();
                with (trans) {
                        return rb ? 100 - ra : ra - 100;
                }
        }
        /**
         * Set brightness offset
         * @param val Offset between -255 and 255
         */
        function setBrightOffset(val:Number) {
                var trans:Object = getTransform();
                with (trans) {
                        rb = gb = bb = val;
                }
                setTransform(trans);
        }
        /**
         * @return Brightness set with setBrightOffset
         * @see setBrightOffset
         */
        function getBrightOffset():Number {
                return getTransform().rb;
        }


                // ----------o Tint


        /**
         * Tint with a color just like Property Inspector
         * @param r Red value between 0 and 255
         * @param g Greeb value between 0 and 255
         * @param b Blue value between 0 and 255
         * @param percent Between 0 and 100
         */
        public function setTint(r:Number, g:Number, b:Number, percent:Number) {
                var ratio = percent / 100;
                var trans = {rb:r*ratio, gb:g*ratio, bb:b*ratio};
                trans.ra = trans.ga = trans.ba = 100 - percent;
                setTransform (trans);
        }
        /**
         * @return tint object containing r, g, b, and percent properties
         * @see setTint
         */
        public function getTint():Object {
                var trans:Object = getTransform();
                var tint:Object = {percent: 100 - trans.ra};
                var ratio:Number = 100 / tint.percent;
                tint.r = trans.rb * ratio;
                tint.g = trans.gb * ratio;
                tint.b = trans.bb * ratio;
                return tint;
        }
        /**
         * tint with a color - alternate approach
         * @param rgb Color number between 0 and 0xFFFFFF
         * @param percent Between 0 and 100
         */
        public function setTint2(rgb:Number, percent:Number) {
                var r:Number = (rgb >> 16) ;
                var g:Number = (rgb >> <img src="http://common.lalex.com/themes/devblog/smilies/icon_cool.gif" alt="8)" class="smiley" /> & 0xFF;
                var b:Number = rgb & 0xFF;
                var ratio:Number = percent / 100;
                var trans:Object = {rb:r*ratio, gb:g*ratio, bb:b*ratio};
                trans.ra = trans.ga = trans.ba = 100 - percent;
                setTransform (trans);
        }
        /**
         * @return a tint object containing rgb (a 0xFFFFFF number) and percent properties
         * @see setTint2
         */
        public function getTint2():Object {
                var trans:Object = getTransform();
                var tint:Object = {percent: 100 - trans.ra};
                var ratio:Number = 100 / tint.percent;
                tint.rgb = (trans.rb*ratio)<<16 | (trans.gb*ratio)<<8 | trans.bb*ratio;
                return tint;
        }


                // ----------o Tint offset


        /**
         * @param r Red value between 0 and 255
         * @param g Greeb value between 0 and 255
         * @param b Blue value between 0 and 255
         */
        public function setTintOffset(r:Number, g:Number, b:Number) {
                var trans:Object = getTransform();
                with (trans) {
                        rb = r;
                        gb = g;
                        bb = b;
                }
                setTransform (trans);
        }
        /**
         * @return Object containing r, g, b properties
         * @see setTintOffset
         */
        public function getTintOffset():Object {
                var t:Object = getTransform();
                return {r:t.rb, g:t.gb, b:t.bb};
        }


                // ----------o Negative and invert

        /**
         * Produce a negative image of the normal appearance
         * @param percent Between 0 and 100
         */
        public function setNegative(percent:Number) {
            var t:Object = {};
            t.ra = t.ga = t.ba = 100 - 2 * percent;
            t.rb = t.gb = t.bb = percent * (255/100);
            setTransform (t);
        }
        /**
         * @return Negative percentage
         * @see setNegative
         */
        public function getNegative():Number {
            return getTransform().rb * (100/255);
        }
        /**
         * Invert the current color values
         */
        public function invert() {
                var trans:Object = getTransform();
                with (trans) {
                        ra = -ra;
                        ga = -ga;
                        ba = -ba;
                        rb = 255 - rb;
                        gb = 255 - gb;
                        bb = 255 - bb;
                }
                setTransform (trans);
        }


                // ----------o Color values

        /**
         * Set red value
         * @param amount Between 0 and 255
         */
        public function setRed(amount:Number) {
                var t = getTransform();
                setRGB (amount << 16 | t.gb << 8 | t.bb);
        }
        /**
         * Get red value
         * @return Value between 0 and 255
         * @see setRed
         */
        public function getRed():Number {
                return getTransform().rb;
        }
        /**
         * Set green value
         * @param amount Between 0 and 255
         */
        public function setGreen(amount:Number) {
                var t = getTransform();
                setRGB (t.rb << 16 | amount << 8 | t.bb);
        }
        /**
         * Get green value
         * @return Value between 0 and 255
         * @see setGreen
         */
        public function getGreen():Number {
                return getTransform().gb;
        }
        /**
         * Set blue value
         * @param amount Between 0 and 255
         */
        public function setBlue(amount:Number) {
                var t = getTransform();
                setRGB (t.rb << 16 | t.gb << 8 | amount);
        }
        /**
         * Get blue value
         * @return Value between 0 and 255
         * @see setBlue
         */
        public function getBlue():Number {
                return getTransform().bb;
        }


                // ----------o Color percentages

        /**
         * Set red percentage
         * @param percent Between -100 and 100
         */
        public function setRedPercent(percent:Number) {
                var trans:Object = getTransform();
                trans.ra = percent;
                setTransform (trans);
        }
        /**
         * Get red percentage
         * @return Value between -100 and 100
         * @see setRedPercent
         */
        public function getRedPercent():Number {
                return getTransform().ra;
        }
        /**
         * Set green percentage
         * @param percent Between -100 and 100
         */
        public function setGreenPercent(percent:Number) {
                var trans:Object = getTransform();
                trans.ga = percent;
                setTransform (trans);
        }
        /**
         * Get green percentage
         * @return Value between -100 and 100
         * @see setGreenPercent
         */
        public function getGreenPercent():Number {
                return getTransform().ga;
        }
        /**
         * Set blue percentage
         * @param percent Between -100 and 100
         */
        public function setBluePercent(percent:Number) {
                var trans:Object = getTransform();
                trans.ba = percent;
                setTransform (trans);
        }
        /**
         * Get blue percentage
         * @return Value between -100 and 100
         * @see setBluePercent
         */
        public function getBluePercent():Number {
                return getTransform().ba;
        }


                // ----------o Color offsets

        /**
         * Set red offset
         * @param offset Between -255 and 255
         */
        public function setRedOffset(offset:Number) {
                var trans:Object = getTransform();
                trans.rb = offset;
                setTransform (trans);
        }
        /**
         * Get red offset
         * @return Value between -255 and 255
         * @see setRedOffset
         */
        public function getRedOffset():Number {
                return getTransform().rb;
        }
        /**
         * Set green offset
         * @param offset Between -255 and 255
         */
        public function setGreenOffset(offset:Number) {
                var trans:Object = getTransform();
                trans.gb = offset;
                setTransform (trans);
        }
        /**
         * Get green offset
         * @return Value between -255 and 255
         * @see setGreenOffset
         */
        public function getGreenOffset():Number {
                return getTransform().gb;
        }
        /**
         * Set blue offset
         * @param offset Between -255 and 255
         */
        public function setBlueOffset(offset:Number) {
                var trans:Object = getTransform();
                trans.bb = offset;
                setTransform (trans);
        }
        /**
         * Get blue offset
         * @return Value between -255 and 255
         * @see setBlueOffset
         */
        public function getBlueOffset():Number {
                return getTransform().bb;
        }

                // ----------o Getter/Setter

        /**
         * RGB value
         * @type Number
         */
        function set _rgb(val:Number) {
                setRGB(val);
        }
        function get _rgb():Number {
                return getRGB();
        }
        /**
         * RGB value
         * @type String
         */
        function set _rgbStr(val:String) {
                setRGBStr(val);
        }
        function get _rgbStr():String {
                return getRGBStr();
        }
        /**
         * Brightness value
         * @type Number
         */
        function set _brightness(b:Number) {
                setBrightness(b);
        }
        function get _brightness():Number {
                return getBrightness();
        }
        /**
         * Brightness offset
         * @type Number
         */
        function set _brightOffset (b:Number) {
                setBrightOffset(b);
        }
        public function get _brightOffset():Number {
                return getBrightOffset();
        }
        /**
         * Negative percentage
         * @type Number
         */
        public function set _negative(p:Number) {
                setNegative(p);
        }
        public function get _negative():Number {
                return getNegative();
        }
        /**
         * Red value
         * @type Number
         */
        public function set _red(v:Number) {
                setRed(v);
        }
        public function get _red():Number {
                return getRed();
        }
        /**
         * Green value
         * @type Number
         */
        public function set _green(v:Number) {
                setGreen(v);
        }
        public function get _green():Number {
                return getGreen();
        }
        /**
         * Blue value
         * @type Number
         */
        public function set _blue(v:Number) {
                setBlue(v);
        }
        public function get _blue():Number {
                return getBlue();
        }
        /**
         * Red percentage
         * @type Number
         */
        public function set _redPercent(v:Number) {
                setRedPercent(v);
        }
        public function get _redPercent():Number {
                return getRedPercent();
        }
        /**
         * Green percentage
         * @type Number
         */
        public function set _greenPercent(v:Number) {
                setGreenPercent(v);
        }
        public function get _greenPercent():Number {
                return getGreenPercent();
        }
        /**
         * Blue percentage
         * @type Number
         */
        public function set _bluePercent(v:Number) {
                setBluePercent(v);
        }
        public function get _bluePercent():Number {
                return getBluePercent();
        }
        /**
         * Red offset
         * @type Number
         */
        public function set _redOffset(v:Number) {
                setRedOffset(v);
        }
        public function get _redOffset():Number {
                return getRedOffset();
        }
        /**
         * Green offset
         * @type Number
         */
        public function set _greenOffset(v:Number) {
                setGreenOffset(v);
        }
        public function get _greenOffset():Number {
                return getGreenOffset();
        }
        /**
         * Blue offset
         * @type Number
         */
        public function set _blueOffset(v:Number) {
                setBlueOffset(v);
        }
        public function get _blueOffset():Number {
                return getBlueOffset();
        }
}
Vous pouvez donc télécharger cette mise à jour si le coeur vous en dit, qui en plus corrige un ch'tit bug qui s'était glissé sur la propriété _blueOffset ! Cette classe inaugure aussi le fait que je n'utiliserais plus le this systématique dans mes classes.

::Télécharger SuperColor.zip::

Un aspect singulier des interfaces face à l'héritage est que le compilateur de Flash MX 2004 ne se contente pas de vérifier si une classe implémente l'interface, mais il vérifie aussi que les méthodes devant être implémentées le sont ...

Pour etre plus clair, j'ai découvert cela en faisant des tests en réimplémentant ma bibliothèque sur les matrices. Ma classe Matrix hérite d'un classe Grid. Cette classe Grid possède une méthode clone(). J'ai voulu créer une interface IClonable pour m'assurer qu'une matrice puisse être clonée, et ayant oublié de créer la méthode, je me suis rendu compte que le compilateur laissait passer malgré tout ... :o En fait, cette méthode existe déjà dans Grid, alors que Grid n'implémente pas IClonable !

Voici le code que le compilateur laisse passer :/*
 * interface IClonable
 */
interface net.lalex.interfaces.IClonable {
        public function clone():Object;
}
/*
 * classe Grid
 */
class net.lalex.data.Grid extends Array {
        // Plein de code ...
        // Retourner un clone de la grille
        public function clone():Object {
                var ret:Grid = new Grid(_gridWidth, _gridHeight);
                ret.copyFrom(this);
                return ret;
        }
        // Copy les éléments d'une autre grille
        public function copyFrom(g:Grid):Void {
                // Code
        }
}
/*
 * classe Matrix
 */
class net.lalex.maths.Matrix extends net.lalex.data.Grid implements net.lalex.interfaces.IClonable {
        // Aucune méthode 'clone()'
}
Normal allez-vous me dire ? Oui, en effet. Mais je ne pensais pas que le compilateur allait si loin. Ca ne m'arrange pas en fait, car j'aurais bien voulu forcer la classe Matrix à surcharger la méthode clone() ...