ActionScript Facile Chapitre 8 Création du composant AS3 TextField

package  com.actionscriptfacile.ui.text
{
    import flash.text.Font;
    import flash.text.FontType;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;
    import flash.text.TextFieldType;
    import flash.text.TextFormat;
    import flash.text.TextFormatAlign;
    import flash.utils.Dictionary;
    import flash.utils.getDefinitionByName;
 
    /**
     * La classe UITextField est une extension de la classe flash.text.TextField de base.
     * Elle inclut quelques fonctionnalités qui permettent de gérer plus facilement la mise
     * en forme d'un champ texte.
     *
     * @author Matthieu
     */
    public class UITextField extends TextField
    {
 
        protected static var m_allowedFonts:Dictionary; 
        // Une liste des différentes polices de caractères autorisées.
 
        protected var m_currentFont:String; // Le nom de la police de caractère utilisée actuellement
        protected var m_maxWidth:Number; // la largeur maximale du champ texte
        protected var m_maxHeight:Number; // la hauteur maximale du champ texte
 
        public function UITextField()
        {
            super();
            /*
             * Création d'une méthode init pour gagner des ressources,
             * en effet en AS3 tout ce qui se trouve dans le constructeur n'est
             * pas optimisé à la compilation,
             * on met donc toutes nos instructions dans une méthode privée init
             *
             */
            init();
        }
 
        /**
         * Initialise proprement les différents éléments du composant
         *
         */
        private function init():void
        {
            // Si le tableau de fonts n'est pas encore initialisé alors ...
            if ( m_allowedFonts == null )
            {
                m_allowedFonts = new Dictionary(); // on le crée
                var fonts:Array = Font.enumerateFonts( true ); // on récupère toutes les polices utilisables
                var max:int = fonts.length - 1;
 
                /**
                 * On boucle sur toutes les polices et on les ajoute à la liste des typos autorisées
                 */
                for ( ; max > -1; max-- )
                {
                    m_allowedFonts[Font( fonts[max] ).fontName ] = fonts[max];
                }
 
                // On définit une police par défaut
                m_currentFont = Font( fonts[ 0 ] ).fontName;
            }
 
            // Puis on définit une hauteur et une largeur maximale théorique.
            m_maxHeight = m_maxWidth = 500;
        }
 
        /**
         * Cette fonction sert à changer le format d'un caractère
         *
         * @param    p_letterIndex    Index du caractère dont on veut changer le formatage
         * @param    p_propertyName    Le nom de la propriété de formatage que l'on veut changer
         * @param    p_value            La valeur de la propriété de formatage
         */
        public function changeLetterFormat( p_letterIndex:int, p_propertyName:String, p_value:* ):void
        {
            changeFormat( p_propertyName, p_value, p_letterIndex, p_letterIndex + 1, false );
        }
 
        /**
         * Cette fonction sert à récupérer le format d'un caractère
         *
         * @param    p_letterIndex    Index du caractère dont on veut récupérer le formatage
         * @return    Un objet de type TextFormat
         */
        public function getLetterFormat( p_letterIndex:int ):TextFormat
        {
            return getTextFormat( p_letterIndex, p_letterIndex );
        }
 
         /**
          * Cette méthode permet un accès direct aux propriétés de l'objet TextFormat du TextField.
          * Elle a pour but de simplifier la mise à jour graphique d'un champ texte par le biais
          * d'un appel à une seule méthode.
          * http://help.adobe.com/fr_FR/AS3LCR/Flash_10.0/flash/text/TextFormat.html
          *
          * @param    p_propertyName nom de la propriété à changer @see flash.text.TextFormat
          * @param    p_value valeur de la propriété
          * @param    p_startIndex index de départ à partir duquel les changements opéreront dans le texte.
          * @param    p_endIndex index de fin.
          */
        public function changeFormat( p_propertyName:String, p_value:*, p_startIndex:int = -1, p_endIndex:int = -1, 
                                      p_isDefault:Boolean = false ):void
        {
            // Si la longueur du champ texte est inférieure à l'index maximal des caractères demandés 
            // alors on arrête tout
            if ( text.length < p_endIndex )
                return;
 
            // On récupère le format des caractères compris entre p_startIndex et p_endIndex
            var format:TextFormat = getTextFormat( p_startIndex, p_endIndex );
 
            // Si le textformat possède la propriété p_propertyName
            if ( format.hasOwnProperty( p_propertyName ) )
            {
                // alors on définit la nouvelle valeur de la propriété en question
                format[ p_propertyName ] = p_value;
            }
 
            // Si on a définit le paramètre p_isDefault à true
            if ( p_isDefault )
            {
                // alors le format devient le format par défaut
                defaultTextFormat = format;
            }
 
            // Enfin, on applique le format au champ texte pour les caractères spécifiés.
            setTextFormat( format, p_startIndex, p_endIndex );
        }
 
        /**
         * Convertir le champ texte en champ de saisie
         */
        public function convertToInput():void { type = TextFieldType.INPUT; }
 
        /**
         * Convertir le champ texte en champ dynamique
         */
        public function convertToDynamic():void { type = TextFieldType.DYNAMIC; }
 
        /**
         * Aligne le champ texte par le centre
         */
        public function alignCenter():void { changeFormat( 'align', TextFormatAlign.CENTER ); }
 
        /**
         * Aligne le champ texte en mode justifié
         */
        public function alignJustify():void { changeFormat( 'align', TextFormatAlign.JUSTIFY ); }
 
        /**
         * Aligne le champ texte par la gauche
         */
        public function alignLeft():void { changeFormat( 'align', TextFormatAlign.LEFT ); }
 
        /**
         * Aligne le champ texte par la droite
         */
        public function alignRight():void { changeFormat( 'align', TextFormatAlign.RIGHT ); }
 
        /**
         * Redimensionne automatiquement le champ texte par le centre
         */
        public function autoSizeLeft():void { autoSize = TextFieldAutoSize.LEFT; };
 
        /**
         * Précise que le champ texte ne doit plus se redimensionner automatiquement
         */
        public function autoSizeNone():void { autoSize = TextFieldAutoSize.NONE; };
 
        /**
         * Redimensionne automatiquement le champ texte par la droite
         */
        public function autoSizeRight():void { autoSize = TextFieldAutoSize.RIGHT; };
 
        /**
         * Redimensionne automatiquement le champ texte par la gauche
         */
        public function autoSizeCenter():void { autoSize = TextFieldAutoSize.CENTER; };
 
        /**
         * Définit la nouvelle police de caractère utilisée pour ce champ texte.
         * Si la police ne fait pas partie des polices autorisées, le système va tenter
         * de la retrouver. En cas d'échec la police ne sera pas changée, dans le cas contraire
         * la nouvelle police sera utilisée et ajoutée à la liste des polices autorisées.
         */
        public function set font( p_font:String ):void
        {
 
            var fontDefinition:Class;
 
            if ( m_allowedFonts[p_font] == null || // Si la police n'est pas autorisée alors ...
                Font( m_allowedFonts[p_font] ).fontType != FontType.DEVICE 
                // Ou qu'il ne s'agit pas d'une typo système
            )
            {
                try
                {
                    // On tente de récupérer sa définition
                    fontDefinition = getDefinitionByName( p_font ) as Class;
 
                    // On l'enregistre auprès du flash player
                    Font.registerFont( fontDefinition );
 
                    // Et on l'ajoute à la liste des typos autorisées
                    m_allowedFonts[ p_font ] = new fontDefinition() as Font;
                }
                catch ( e:Error )
                {
                    // Dans le cas ou l'on n'est pas arrivé à récupérer la définition de la classe 
                    // On arrête tout
                    return;
                }
 
            }
 
            // S'il s'agit d'une police du système alors emebedFonts = false sinon embedFonts = true
            embedFonts = ( Font( m_allowedFonts[p_font] ).fontType != FontType.DEVICE );
 
            // On redéfinit la font utilisée
            m_currentFont = p_font;
 
            // Et on applique la nouvelle police de caractères au format
            changeFormat( 'font', p_font );
        }
 
        /**
         * Récupère le nom de la police utilisée pour ce champ texte
         */
        public function get font():String { return m_currentFont; }
 
        /**
         * Récupère / définit la valeur de la largeur maximale autorisée pour ce champ texte
         */
        public function get maxWidth():Number { return m_maxWidth; }
        public function set maxWidth(value:Number):void { m_maxWidth = value; }
 
        /**
         * Récupère / définit la valeur de la hauteur maximale autorisée pour ce champ texte
         */
        public function get maxHeight():Number { return m_maxHeight; }
        public function set maxHeight(value:Number):void { m_maxHeight = value; }
 
        /**
         * Définit la largeur / hauteur du champ texte
         */
        override public function set width( p_width:Number ):void { 
                super.width = ( p_width > m_maxWidth ) ? m_maxWidth : p_width; }
        override public function set height( p_height:Number ):void { 
                super.height = ( p_height > m_maxHeight ) ? m_maxHeight : p_height; }
 
        /**
         * Détruit proprement un composant de type UITextField
         */
        public function destroy():void
        {
            // La police de caractères est passée à null.
            m_currentFont = null;
 
            // On enlève le composant de la displayList de son parent
            if ( parent && parent.contains( this ) )
            {
                parent.removeChild( this );
            }
 
            delete this;
        }
 
    }
 
}

package
{
    import com.actionscriptfacile.ui.combo.element.ComboBoxElement;
    import com.actionscriptfacile.ui.combo.ComboBox;
    import com.actionscriptfacile.ui.text.UITextField;
 
    import com.as3facileexemple.skin.classic.DefaultComboBoxSkin;
 
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.text.Font;
 
    /**
     * Exemple d'utilisation du composant UITextField
     *
     * @author Matthieu
     */
    public class UITextFieldExample extends Sprite
    {
 
        protected var m_comboFonts:ComboBox;
        protected var m_textField:UITextField;
 
        public function UITextFieldExample()
        {
 
            /**
             * On construit la combobox
             */
            m_comboFonts = new ComboBox();
            m_comboFonts.applySkin( new DefaultComboBoxSkin() );
 
            // On écoute les changements qui interviennent dans la combobox
            m_comboFonts.addEventListener(Event.CHANGE, changeHandler );
            m_comboFonts.resize( 300, 100 );
            m_comboFonts.componentsHeight = 25;
 
            // On ajoute tous les noms de polices autorisées comme élément de la combobox
            var fonts:Array = Font.enumerateFonts( true );
 
            var boxElement:ComboBoxElement;
 
            for each ( var font:Font in fonts )
            {
                boxElement = m_comboFonts.addElement( font.fontName, font.fontName );
                boxElement.labelField.changeFormat("color", Math.random() * 0X00FFFFFF);
                // changement de la couleur du texte
                boxElement.labelField.changeFormat("size", 14);
                // changement de la taille de la police du texte
            }
 
            /**
             * On construit un UITextField
             */
            m_textField = new UITextField();
            m_textField.text = 'Enjoy  ';
 
            m_textField.x = m_textField.y = 5;
            m_textField.width = m_textField.maxWidth = 300;
            m_textField.height  = m_textField.maxHeight = 30;
 
            m_comboFonts.y = m_textField.y + m_textField.height + 20;
            m_comboFonts.x = 5;
 
            addChild( m_comboFonts );
            addChild( m_textField );
        }
 
        /**
         * Fonction servant à écouter le changement de police au sein de la combobox.
         * On applique la police à l'UITextField que l'on a crée et placé sur la
         * scène.
         *
         * @param    e    Evenement de type Event.CHANGE
         */
        private function changeHandler(e:Event):void
        {
            m_textField.font = m_comboFonts.currentLabel;
        }
 
    }
 
}