ADOBE FLASH BUILDER 4.5 User Manual

Download

Utilisation d’

ADOBE® FLASH® BUILDERTM 4.5

Informations juridiques

Pour consulter les informations juridiques, voir http://help.adobe.com/fr_FR/legalnotices/index.html.

Dernière mise à jour le 8/7/2011

Sommaire

Chapitre 1 : A propos de Flash Builder

Applications que vous pouvez créer à l’aide de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Fonctionnalités qui accélèrent le développement d’applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

Fonctionnalités d’exécution et de débogage de projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

Versions de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

Configurations Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Client de l’Aide de la communauté Adobe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Chapitre 2 : Initiation à Flash Builder

Workbench Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Perspectives et vues de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Editeurs Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Projets dans Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Ressources des projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

iii

Chapitre 3 : Outils de développement de code dans Flash Builder

Assistant de contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

Assistant rapide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

Remplacement ou implémentation de méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

Modèles de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Remplissage du code de métadonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

Personnalisation des modèles de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Génération à partir de l’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Génération de fonctions d’accesseur Get ou Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Vérification de la syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

Mise en surbrillance des erreurs de référence non identifiée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Recherche de références et restructuration du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Formatage, navigation et organisation du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

Chapitre 4 : Utilisation des projets dans Flash Builder

Création de projets dans Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Exportation et importation de projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

Création de projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

Exécution et débogage des applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

Exportation d’une application vers une version validée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

Création de packages d’application AIR avec Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

Chapitre 5 : Débogage d’outils dans Flash Builder

Perspective Débogage Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

Débogage de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

Chapitre 6 : Profilage d’outils dans Flash Builder

Perspective Profil Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

Profilage d’une application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Sommaire

Fonctionnement du profileur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

Utilisation du profileur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

Récupération de place . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

Identification des zones à problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

Filtres du profileur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

Chapitre 7 : Outils de test unitaire dans Flash Builder

Environnement de test FlexUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

Création de tests FlexUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

Exécution des tests FlexUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

Configuration des tests FlexUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

Affichage des résultats de l’exécution d’un test FlexUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180

Chapitre 8 : Développement d’applications avec Flex

Flux de travail de base pour développer une application avec Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

Création d’interfaces utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

Génération de gestionnaires d’événement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

Accès aux services de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

Surveillance des applications qui accèdent aux services de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

Utilisation de projets de bibliothèque Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

Création de composants MXML personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

Création de modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

Intégration de Flex avec les applications HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240

Chapitre 9 : Utilisation de Flash Builder avec Flash Professional

Création d’un projet Flash Professional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

Opérations possibles dans un projet Flash Professional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

Définition des propriétés des projets Flash Professional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

Création et modification de composants Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

Gestion de la sécurité de Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248

Chapitre 10 : Utilisation de Flash Builder avec Flash Catalyst

Flux de travaux entre Flash Catalyst et Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250

Intégration de Flash Catalyst et de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254

Chapitre 11 : Personnalisation de Flash Builder

Préférences Adobe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

Personnalisation du workbench . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

Préférences de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

Extension de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

Dernière mise à jour le 8/7/2011

Chapitre 1 : A propos de Flash Builder

Adobe® Flash® Builder™ est un environnement de développement intégré (IDE, integrated development environment) permettant de créer des applications Internet riches (RIA, rich Internet applications) utilisables sur plusieurs plateformes pour les ordinateurs de bureau et un grand nombre de périphériques mobiles. Il comporte également des outils de test, de débogage et de profilage favorisant productivité et efficacité.

Flash Builder est basé sur Eclipse, un environnement IDE de type « open source », et fournit tous les outils requis pour développer des applications qui utilisent la structure Flex et ActionScript 3.0. Flash Builder s’exécute sous Microsoft Windows et Apple Mac OS X et est disponible en plusieurs versions. Les options de configuration d’installation vous permettent d’installer Flash Builder en tant que série de plug-ins dans une installation existante du workbench Eclipse ou de créer une installation autonome comprenant le workbench Eclipse.

Découvrez les nouvelles fonctionnalités de Flash Builder 4.5 dans l’article Nouveautés de Flash Builder 4.5 d’Andrew Shorten, chef de produit chez Adobe.

Consultez une vidéo de Serge Jespers, fameux développeur Adobe, pour bénéficier d’une présentation des

fonctionnalités de Flash Builder 4.5.

Applications que vous pouvez créer à l’aide de Flash Builder

Vous pouvez créer des applications utilisant la structure Adobe Flex® framework, MXML, Adobe Flash Player, Adobe AIR®, ActionScript 3.0 et Adobe® LiveCycle® Data Services ES, ainsi que les composants Adobe® Flex® Charting suivants :

• Projets Flex - Créez des projets Flex compatibles avec toute technologie de serveur dorsal, notamment Adobe

ColdFusion®, Adobe LiveCycle® Data Services et PHP.

Voir « Création de projets Flex » à la page 88 et « Développement d’applications avec Flex » à la page 181.

• Projets ActionScript - Créez des projets ActionScript utilisant l’API Flash (et non la structure Flex).

Voir « Création de projets ActionScript » à la page 91.

• Projets mobiles – Créez des applications mobiles Flex pour la plateforme Google Android et des applications

mobiles ActionScript pour la plateforme Apple iOS.

Voir « Création de projets Flex mobiles » à la page 90 et « Création de projets ActionScript mobiles » à la page 91.

Pour plus d’informations sur le développement d’applications mobiles avec Flex et Flash Builder, voir

Développement d’applications mobiles avec Flex et Flash Builder.

• Projets de bibliothèque - Créez des bibliothèques de code personnalisées que vous pourrez déployer en tant que

fichiers de bibliothèque de composants (SWC) afin de les partager entre vos applications ou de les distribuer à d’autres développeurs.

Voir « Utilisation de projets de bibliothèque Flex » à la page 227.

• Projets Flash Professional – Créez des projets Flash Professional pour modifier et déboguer des fichiers Flash FLA

ou XFL créés avec Flash Professional CS5.

Voir « Utilisation de Flash Builder avec Flash Professional » à la page 245.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

A propos de Flash Builder

• Projets compatibles Flash Catalyst - Vous pouvez créer des projets compatibles Flash Catalyst pour permettre aux

créateurs et aux développeurs de collaborer et de travailler sur un même projet. Vous pouvez facilement partager un projet compatible avec Flash entre Flash Builder et Flash Catalyst par le biais des fichiers FXP ou FXPL.

Voir « Création de projets compatibles avec Flash Catalyst » à la page 92.

Consultez l’article sur les flux de travaux entre Flash Builder et Flash Catalyst, Présentation des nouveaux flux de

travaux de Flash Catalyst CS5.5 et Flash Builder 4.5 de Jacob Surber, chef de produit chez Adobe.

• Composants MXML personnalisés - Créez des composants personnalisés, puis accédez-y facilement par le biais

de la vue Composants Flash Builder.

Voir « Création de composants MXML personnalisés » à la page 232.

Vous pouvez aussi créer des composants ActionScript personnalisés. Voir « Création d’une classe ActionScript » à la page 42.

Fonctionnalités qui accélèrent le développement d’applications

Flash Builder dispose des outils nécessaires au développement d’applications qui utilisent la structure Flex et ActionScript 3.0. Vous pouvez :

• Accès aux services de données - Utilisez les outils et les assistants Flash Builder pour créer des applications qui

accèdent aux services de données distants.

Voir Présentation de l’accès aux services de données.

• Personnalisation de workbench Flash Builder - Personnalisez le workbench en fonction de vos besoins

personnels en termes de développement. Vous pouvez par exemple organiser l’interface de manière à inclure vos outils favoris dans une présentation particulière.

Voir « Personnalisation du workbench » à la page 259.

• Modification du code - Rédigez et éditez le code source de l’application à l’aide des outils de développement de

code de Flash Builder. Ceux-ci incluent la restructuration de code, les conseils de code, la navigation simplifiée dans le code et la vérification automatique de la syntaxe, entre autres.

Voir « Outils de développement de code dans Flash Builder » à la page 48.

• Création d’une interface utilisateur - L’éditeur MXML en mode Création permet de créer des applications en

utilisant des options de présentation, de faire glisser des composants dans la zone de travail de création, puis de les repositionner et de les redimensionner au besoin, afin de simplifier l’utilisation des états d’affichage, etc.

Voir « Création d’interfaces utilisateur » à la page 182.

• Publication du code source - Publiez le code source de votre application afin de permettre aux utilisateurs et aux

autres développeurs d’y accéder.

Voir « Publication du code source » à la page 118.

• Gestion de projets, de dossiers, de fichiers et d’autres ressources - Créez, modifiez et supprimez des projets et des

ressources, générez des liens vers des ressources extérieures à votre projet, etc.

Voir « Projets dans Flash Builder » à la page 33 et « Ressources des projets » à la page 40.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

A propos de Flash Builder

Fonctionnalités d’exécution et de débogage de projets

Flash Builder intègre des outils de création, de test, de débogage et de profilage qui vous permettent d’améliorer votre productivité :

• Création de projets - Flash Builder compile et crée automatiquement vos applications de débogage ou de

production. Vous pouvez aussi créer des scripts de création personnalisés à l’aide d’Apache Ant.

Voir « Création de projets » à la page 100.

• Exécution des applications et gestion des configurations de lancement - Exécutez vos applications dans un

navigateur Web, AIR ou dans un Flash Player autonome. Création de configurations de lancement personnalisées pour contrôler l’exécution des applications.

Voir « Exécution et débogage des applications » à la page 120 et « Gestion des configurations de lancement » à la page 120.

• Débogage des applications - Déboguez vos applications à l’aide des outils de débogage intégrés.

Voir « Débogage d’outils dans Flash Builder » à la page 134.

• Exécution et débogage des applications mobiles – Exécutez et déboguez vos applications sur le bureau ou sur un

périphérique.

Voir Exécution et débogage des applications mobiles.

• Profilage des applications - Identifiez les problèmes de performance et les fuites de mémoire des applications à

l’aide des outils de profilage de Flash Builder.

Voir « Profilage d’outils dans Flash Builder » à la page 145.

• Surveillance des applications qui accèdent aux services de données - Utilisez le Moniteur de réseau pour générer

une piste d’audit détaillée de l’ensemble des données qui circulent entre vos applications et le serveur dorsal.

Voir « Surveillance des applications qui accèdent aux services de données » à la page 224.

Versions de Flash Builder

Flash Builder est disponible en deux versions : Standard et Premium.

Flash Builder version Standard Cette version fournit un environnement IDE complet qui vous permet de créer des

applications à l’aide de la structure Flex et de l’API Flash. Flash Builder version Standard inclut également des éditeurs MXML, ActionScript et CSS, ainsi que des outils de débogage. Il fournit une bibliothèque de diagrammes et de graphiques interactifs qui vous permettent de créer des tableaux de bord riches, des analyses de données interactives et des composants de visualisation des données.

Flash Builder version Premium Outre les fonctionnalités de la version Standard, Flash Builder Premium comporte des

outils de profilage de la mémoire et des performances ainsi que des outils de tests automatisés. Utilisez le Moniteur de réseau pour consulter les données qui sont transmises entre une application client et un service de données. L’environnement de test FlexUnit permet de générer et de modifier des tests pouvant se répéter. Les tests pouvant se répéter s’exécutent à partir de scripts, directement dans Flash Builder ou en dehors de l’environnement Flash Builder. Les fonctionnalités de génération par ligne de commande vous permettent de synchroniser les paramètres de génération d’un développeur avec une génération nocturne.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

A propos de Flash Builder

Flash Builder pour PHP version Standard Flash Builder pour PHP version Standard fournit un environnement IDE

PHP complet qui inclut Flash Builder version Standard intégré avec Zend Studio 8. Vous pouvez créer des applications mobiles, Web et de bureau utilisant PHP, Flex et ActionScript.

Flash Builder pour PHP version Premium Outre les fonctionnalités de la version Standard, Flash® Builder™ 4.5 pour

PHP version Premium inclut des outils de test professionnels, dont notamment des profileurs, la surveillance du réseau, une infrastructure de test automatisée, l’intégration avec les tests FlexUnit et la prise en charge de la génération par ligne de commande.

Pour plus d’informations sur Flash Builder pour PHP, voir Présentation de Flash Builder 4.5 pour PHP.

Configurations Flash Builder

Flash Builder fournit un programme d’installation unique disponible au téléchargement, avec les deux options de configuration suivantes :

Configuration autonome Installe Flash Builder sous forme d’environnement de développement intégré (IDE)

autonome. La configuration autonome est spécifiquement créée pour le développement d’applications qui utilisent l’infrastructure Flex et ActionScript 3.0. Elle est idéale pour les nouveaux utilisateurs et pour ceux qui souhaitent développer des applications en utilisant uniquement l’infrastructure Flex et ActionScript 3.0.

Configuration plug-in Configure Flash Builder pour une exécution en tant que plug-in au sein d’une installation

Eclipse™ existante. Votre ordinateur doit disposer d’Eclipse 3.6 32 bits (Windows) ou d’Eclipse 3.6 Cocoa 32 bits (Mac) pour exécuter la configuration plug-in.

Les configurations plug-in et autonome de Flash Builder fournissent les mêmes fonctionnalités. Si vous ne savez pas quelle configuration utiliser, suivez les recommandations suivantes :

• Si Eclipse 3.6 est déjà installé, utilisez la configuration plug-in pour ajouter les fonctionnalités de Flash Builder à la

copie existante d’Eclipse.

• Si aucune version d’Eclipse n’est installée et que votre objectif principal est de développer des applications Flex et

ActionScript, utilisez la configuration autonome de Flash Builder. Cette configuration vous permet également d’installer d’autres plug-ins Eclipse afin d’étendre la portée de vos futurs travaux de développement.

Pour obtenir des informations détaillées sur l’installation de Flash Builder, consultez les notes de mise à jour de Flash

Builder 4.5.

Client de l’Aide de la communauté Adobe

Flash Builder utilise le client CHC (Adobe Community Help Client) comme moteur de recherche. Le CHC est une application AIR qui remplace le moteur Eclipse Help pour Flash Builder et constitue la plateforme de prochaine génération pour l’aide d’Adobe. Le client CHC se caractérise par les propriétés suivantes :

• Toujours en ligne

Si vous disposez d’une connexion réseau, le client CHC accède au contenu situé sur le Web pour vous fournir en permanence les informations les plus récentes. En l’absence de connexion Internet, il est également opérationnel en mode local.

• Centré sur la recherche

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

A propos de Flash Builder

Vous pouvez utiliser les fonctions de recherche de l’Aide de la communauté (adobe.com) ou procéder à une recherche locale. La recherche de l’Aide de la communauté rassemble les différentes ressources, y compris celles de sites tiers. La recherche adobe.com comporte des critères vous permettant d’en restreindre la portée.

• Navigation en contexte

La navigation en contexte fournit un ensemble généré dynamiquement de liens associés dirigeant vers des pages clés.

• Evaluation et commentaires

Ajoutez des commentaires, des évaluations et des contributions au contenu de l’Aide et aux ressources Adobe en ligne depuis le client CHC. Vous devez disposer d’un ID Adobe valide pour ajouter des commentaires et des évaluations.

Dernière mise à jour le 8/7/2011

Chapitre 2 : Initiation à Flash Builder

Workbench Flash Builder

Le workbench Flash Builder est un environnement de développement complet qui vous aide à développer des applications utilisant la structure Adobe Flex®, et ActionScript 3.0. Vous pouvez développer des applications à déployer dans Adobe Flash Player, des applications de bureau à déployer dans Adobe AIR® et des applications mobiles à déployer sur plusieurs types de périphériques mobiles.

Les informations nécessaires à l’utilisation de Flash Builder sont présentées dans la documentation de Flash Builder. Si vous utilisez d’autres plug-ins Eclipse (par exemple, CVS ou Java) avec Flash Builder, ou si vous souhaitez étendre les plug-ins Flash Builder, voir Guide de référence des extensibilités Adobe Flash Builder.

Workbench Le terme workbench se réfère à l’environnement de développement Flash Builder qui contient tous les

outils permettant de développer des applications. Le workbench contient trois éléments principaux : les perspectives, les éditeurs et les vues. Vous utilisez ces trois composants dans différentes combinaisons à différents stades du processus de développement de l’application.

Remarque : pour plus d’informations sur certaines fonctionnalités du workbench Eclipse, voir le guide de l’utilisateur du workbench Eclipse à l’adresse http://help.eclipse.org/help31/index.jsp.

Perspective Une perspective représente un groupe de vues et d’éditeurs du workbench. Flash Builder contient deux

perspectives : la perspective Développement Flash pour le développement des applications et la perspective Débogage Flash pour les applications de débogage. Flash Builder Premium contient également la perspective Profil Flash.

Si vous utilisez la configuration plug-in de Flash Builder (voir « Configurations Flash Builder » à la page 4), le workbench peut contenir d’autres perspectives telles qu’une perspective Java contenant des éditeurs et des vues permettant de développer des applications Java.

Voir « Perspectives et vues de Flash Builder » à la page 7.

Editeur Un éditeur vous permet d’éditer différents types de fichier. Les éditeurs dont vous disposez varient selon le

nombre et le type de plug-ins Eclipse installés. Flash Builder contient des éditeurs permettant de rédiger du code MXML, ActionScript 3.0 et CSS (Cascading Style Sheets, feuilles de style en cascade).

Voir « Editeurs Flash Builder » à la page 20 et « Outils de développement de code dans Flash Builder » à la page 48.

Vues Une vue comporte généralement un éditeur. Par exemple, lors de l’édition MXML, les vues Composants et

Propriétés apparaissent également dans la perspective Développement Flash. Ces vues prennent en charge le développement d’applications et s’affichent par conséquent lorsqu’un fichier MXML est ouvert en édition.

Voir « Utilisation de vues » à la page 19.

Le terme vue est synonyme de panneau, ce dernier étant utilisé dans les versions précédentes de Flash Builder, dans Adobe Dreamweaver® et dans d’autres outils de développement Adobe.

Espace de travail A ne pas confondre avec le workbench, un espace de travail représente une zone définie d’un système

de fichiers contenant les ressources (fichiers et dossiers) constituant vos projets d’application. Vous ne pouvez travailler que dans un seul espace de travail à la fois, mais vous pouvez cependant sélectionner un espace de travail différent à chaque lancement de Flash Builder.

Voir « Projets dans Flash Builder » à la page 33.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Ressource Le terme ressource est utilisé de façon générique pour désigner les fichiers et dossiers des projets d’un espace

de travail.

Voir « Ressources des projets » à la page 40.

Projet Toutes les ressources constituant vos applications figurent dans des projets. Vous ne pouvez pas créer une

application dans Flash Builder sans créer au préalable un projet. Flash Builder prend en charge les différents types de projets, selon le type d’application que vous créez.

Voir « Types de projets » à la page 34 et « Utilisation des projets dans Flash Builder » à la page 88.

Configuration de lancement Une configuration de lancement est créée pour chacun de vos projets. Elle définit les

paramètres de projet utilisés lors de l’exécution et du débogage de vos applications. Par exemple, les noms et emplacements des fichiers SWF d’application compilés sont contenus dans la configuration de lancement, et vous pouvez modifier ces paramètres.

Voir « Gestion des configurations de lancement » à la page 120.

Voir aussi

« Personnalisation du workbench » à la page 259

Perspectives et vues de Flash Builder

Pour prendre en charge une tâche particulière ou un groupe de tâches, les éditeurs et les vues correspondantes sont combinés dans une perspective. L’ouverture d’un fichier associé à une perspective particulière conduit à l’affichage automatique de cette perspective.

La configuration autonome de Flash Builder propose trois perspectives :

• Développement Flash

Voir « Perspective Développement Flash » à la page 8.

• Débogage Flash

Voir « Perspective Débogage Flash » à la page 134.

• Profil Flash

Voir « Perspective Profil Flash » à la page 145.

Remarque : la perspective Profil Flash est disponible dans Flash Builder Premium.

Ouverture et changement de perspectives

Les perspectives changent automatiquement selon la tâche en cours. Par exemple, si vous créez un projet Flex, le workbench affiche la perspective Développement. Si vous lancez une session de débogage, la perspective Débogage Flash s’affiche lorsque le premier point d’arrêt est atteint.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Vous pouvez également changer manuellement de perspectives en sélectionnant Fenêtre > Ouvrir la perspective. Vous pouvez également utiliser la barre des perspectives, située dans la barre d’outils principale du workbench.

Le titre de la perspective que vous ouvrez remplace celui de la perspective précédemment affichée. Une icône apparaît en regard du titre. Elle permet de parcourir rapidement les perspectives dans la même fenêtre. Par défaut, les perspectives s’affichent dans la même fenêtre.

Si vous utilisez la configuration plug-in de Flash Builder et que vous avez installé d’autres plug-ins Eclipse, d’autres perspectives peuvent s’afficher. Chaque plug-in Eclipse propose des perspectives prédéfinies, mais vous pouvez les personnaliser ou créer vos propres perspectives. Pour afficher la liste complète des perspectives, sélectionnez Fenêtre > Ouvrir la perspective > Autre.

Perspective Développement Flash

La perspective Développement Flash comporte les éditeurs et les vues dont vous avez besoin pour créer des applications pour la structure Flex. Lorsque vous créez un projet, Flash Builder affiche la perspective Développement pour que vous puissiez commencer à développer une application.

L’exemple suivant illustre les vues Explorateur de packages, Structure et Erreurs :

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Le point central de la perspective (et du workbench en général) est la zone de l’éditeur. Elle affiche tous les documents actuellement ouverts dans une interface à plusieurs onglets

Lorsque vous créez un projet Flex, le fichier d’application MXML principal s’ouvre dans la zone de l’éditeur. Vous pouvez ensuite ouvrir et parcourir les documents MXML, ActionScript et CSS que vous utilisez. Pour plus d’informations, voir « Editeurs Flash Builder » à la page 20.

Perspective Développement Flash en mode Source

En mode Source (modification de code), la perspective Développement contient des éditeurs et les vues correspondantes suivantes :

Vue Explorateur de packages

La vue Explorateur de packages contient l’ensemble des projets et des ressources de l’espace de travail et constitue par conséquent un élément essentiel du workbench Flash Builder. Elle apparaît toujours dans les perspectives Développement et Débogage.

Dans l’Explorateur de packages, vous pouvez sélectionner une ressource et en afficher les propriétés.

1 Dans l’Explorateur de packages, sélectionnez une ressource.

2 Sélectionnez Fichier > Propriétés.

Pour plus d’informations sur l’Explorateur de packages et sur l’utilisation de projets, voir « Gestion de projets » à la page 35.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Vue Structure

En mode Source, la vue Structure offre une présentation hiérarchique de la structure du code du document MXML ou ActionScript sélectionné, ce qui vous permet d’inspecter et de parcourir les sections ou lignes de code du document. La vue Structure affiche également les alertes d’erreur de syntaxe générées par le compilateur. Cette vue apparaît également lorsque vous utilisez l’éditeur ActionScript.

Pour plus d’informations sur l’utilisation de la vue Structure en mode Source, voir « Utilisation de la vue Structure

pour parcourir et examiner le code » à la page 79.

Vue Erreurs

Lorsque vous saisissez du code, le compilateur Flash Builder détecte les erreurs de syntaxe et d’autres erreurs de compilation et les affiche dans la vue Erreurs. L’Explorateur de packages signale les nœuds contenant des erreurs.

Lorsque vous déboguez vos applications, les erreurs, avertissements et autres informations apparaissent dans la vue Erreurs. Chaque erreur ou avertissement contient un message, le fichier et le dossier correspondants ainsi que le numéro de la ligne dans le fichier. Les erreurs demeurent affichées dans la vue Erreurs jusqu’à ce que vous les corrigiez ou qu’elles soient résolues.

Remarque : vous pouvez également ajouter les vues Tâches et Signets. Ces vues offrent des raccourcis supplémentaires vous permettant de gérer et de parcourir le code. Pour plus d’informations sur ces vues, voir « Utilisation de marqueurs » à la page 83. Pour une présentation des vues optionnelles disponibles dans Flash Builder, voir « Autres vues utiles du

workbench » à la page 16.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Vue ASDoc

Flash Builder affiche le contenu ASDoc correspondant au code que vous saisissez ou aux éléments de code sur lesquels le curseur de la souris est positionné. Il affiche en outre dans la vue ASDoc le contenu ASDoc correspondant au code sélectionné.

Pour plus d’informations, voir « Affichage du résumé du guide de référence ActionScript » à la page 51.

Vue Données/Services

Flash Builder propose des assistants et des outils qui permettent de se connecter aux services de données. Utilisez la vue Données/Services pour vous connecter aux services de données. Une fois établie la connexion à un service de données, la vue Données/Services affiche le service, les types des données retournées et les opérations disponibles pour le service. Elle vous permet en outre de configurer l’accès au service et de lier les données retournées aux composants de l’interface utilisateur.

Pour plus d’informations, voir Construction d’applications centrées sur les données avec Flash Builder.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Vue Moniteur de réseau

Le Moniteur de réseau permet d’analyser les données transmises entre une application et le ou les services de données. Il est disponible avec Flash Builder Premium.

Pour plus d’informations, voir « Surveillance des applications qui accèdent aux services de données » à la page 224.

Perspective Développement Flash en mode Création

Le mode Création de l’éditeur MXML représente visuellement le code édité en mode Source. Il contient cependant, par rapport à ce dernier, des vues supplémentaires prenant en charge les tâches de création. Ces vues sont la vue Composants, Propriétés, Aspect, Etats et Erreurs du mode Création.

Le mode Création comporte en outre la vue Structure qui affiche la structure MXML des applications. Pour plus d’informations sur la création d’applications dans Flash Builder, voir « Création d’interfaces utilisateur » à la page 182.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Remarque : le mode Création n’est pas disponible avec les projets ActionScript. Pour prévisualiser l’interface utilisateur des applications ActionScript, créez et exécutez les applications. Pour plus d’informations sur l’utilisation d’ActionScript, voir « Projets ActionScript » à la page 34 et « Exécution et débogage des applications » à la page 120.

En mode Création, la perspective Développement contient l’éditeur MXML et les vues suivantes :

Vue Composants

La vue Composants contient tous les composants Flex standard. Vous pouvez les sélectionner et les ajouter à la zone de création. Cette vue contient également les composants personnalisés que vous créez.

Pour plus d’informations, voir « Création et modification de composants Flash » à la page 246.

Vue Etats

Flex vous permet de créer des applications dont l’apparence varie selon les événements déclenchés directement par l’utilisateur ou générés de façon programmée. Ces changements d’interface utilisateur sont appelés états d’affichage. Vous créez et gérez les états d’affichage dans la vue Etats.

Pour plus d’informations sur les états d’affichage, voir « Ajout d’états d’affichage et de transitions » à la page 196.

Vue Aspect

La vue Aspect vous permet de définir le style global de l’application pour le texte et les couleurs. Vous pouvez également y définir le thème des applications du projet.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Panneau Aspect

Pour plus d’informations, voir « Application de styles » à la page 192.

Vue Style

La vue Style vous permet de définir le style des différents composants. Les styles définissables varient en fonction du composant.

Panneau Style

Pour plus d’informations, voir « Application de styles » à la page 192.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Vue Propriétés Flex

Lorsqu’un composant est sélectionné, ses propriétés s’affichent dans la vue Propriétés Flex. Vous pouvez définir et éditer ces propriétés en fonction de vos besoins. Vous pouvez afficher les propriétés d’un composant de façon graphique (comme l’illustre l’exemple suivant), par catégories ou sous forme d’une liste alphabétique.

Pour plus d’informations, voir « Définition des propriétés des composants » à la page 27.

Vue Structure

En mode Création, la vue Structure présente une vue hiérarchique de la structure MXML de vos applications. Vous pouvez facilement parcourir la structure d’une application en sélectionnant des instructions de balises MXML et des composants individuels. L’élément sélectionné dans la vue Structure est mis en surbrillance dans la vue Création.

Pour plus d’informations sur l’utilisation de la vue Structure en mode Création, voir « Inspection de la structure de

votre MXML » à la page 30.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Vue Erreurs du mode Création

Lorsque la vue Création s’initialise, si des erreurs sont détectées avec l’éditeur ou le projet, elles sont affichées dans la vue Erreurs du mode Création.

Le panneau Erreurs du mode Création présente la liste des erreurs associées au mode Création de l’éditeur initialisé. Les erreurs sont organisées dans une arborescence.

Lorsque vous sélectionnez une erreur dans le panneau Détails de l’erreur du mode Création, les détails de l’erreur s’affichent dans le panneau Détails de l’erreur. Lorsque vous fermez un projet, les erreurs associées à ce projet sont supprimées de la vue Erreurs du mode Création.

Remarque : la vue Erreurs du mode Création s’affiche uniquement lorsque le mode Création est activé. Si vous désactivez le mode Création (Désélectionnez Fenêtre > Activer le mode Création), la vue Erreurs du mode Création ne s’affiche pas.

Autres vues utiles du workbench

Outre les éditeurs et les vues associées aux perspectives Développement, Débogage et Profil par défaut de Flash Builder, le workbench contient des vues supplémentaires. Ces vues optionnelles sont classées par type et associées à des fonctionnalités distinctes du workbench ou à des plug-ins Eclipse spécifiques.

Pour accéder aux vues qui n’apparaissent pas déjà dans une perspective et les ajouter au workbench, sélectionnez Fenêtre > Afficher la vue > Autre.

Ces vues incluent les vues Tâches, Signets et Recherche, lesquelles vous aident à simplifier le processus de développement de l’application.

Après avoir ajouté une vue à la perspective active, vous pouvez l’enregistrer en tant que partie de la perspective. Pour plus d’informations, voir « Personnalisation d’une perspective » à la page 18.

Vous pouvez également créer des vues rapides qui facilitent l’accès aux vues fréquemment utilisées. Pour plus d’informations, voir « Création et utilisation des vues rapides » à la page 19.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Vue Signets

La vue Signets sert à gérer les signets que vous ajoutez à des lignes de code spécifiques ou à des ressources. Tout comme dans un navigateur Web, les signets permettent d’effectuer le suivi d’éléments importants. La sélection d’un signet recherche et affiche ce signet dans le workbench.

Voir aussi

« Utilisation de marqueurs » à la page 83

Vue Recherche

La vue Recherche s’affiche automatiquement lorsque vous recherchez des ressources dans l’espace de travail. Elle permet de définir des recherches, accéder à des recherches précédentes et filtrer la liste des résultats de la recherche.

Voir aussi

« Recherche de ressources dans le workbench » à la page 43

Utilisation de perspectives

Définition de la perspective par défaut

Le mot default entre parenthèses qui suit le nom de la perspective indique qu’il s’agit de la perspective par défaut.

1 Ouvrez la boîte de dialogue Préférences et sélectionnez Général > Perspectives.

2 Sous Perspectives disponibles, sélectionnez la perspective à définir par défaut, puis cliquez sur Perspective par

défaut.

3 Cliquez sur OK.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Ouverture de perspectives dans une nouvelle fenêtre

Vous pouvez ouvrir les perspectives dans une nouvelle fenêtre.

1 Ouvrez la boîte de dialogue Préférences et sélectionnez Général > Perspectives.

2 Sous Ouverture d’une nouvelle perspective, sélectionnez Dans une nouvelle fenêtre.

Pour rétablir les valeurs par défaut, sélectionnez Dans la même fenêtre.

3 Cliquez sur OK.

Personnalisation d’une perspective

Pour modifier la mise en forme d’une perspective, changez les éditeurs et les vues visibles dans une perspective donnée. Par exemple, vous pouvez afficher la vue Signets dans une perspective et la masquer dans une autre.

Pour créer une perspective, procédez comme suit :

1 Ouvrez une perspective existante.

2 Affichez les vues et les éditeurs de votre choix.

3 Sélectionnez Fenêtre > Perspective > Sauvegarder la perspective sous (Fenêtre > Sauvegarder la perspective sous

dans la configuration plug-in de Flash Builder).

Dans la boîte de dialogue Sauvegarder la perspective sous, entrez le nouveau nom de la perspective, puis cliquez sur OK.

Pour configurer une perspective, procédez comme suit :

1 Ouvrez la perspective à configurer.

2 Sélectionnez Fenêtre > Personnaliser la perspective.

3 Sélectionnez les onglets Raccourcis ou Commandes en fonction des éléments que vous souhaitez ajouter à la

perspective personnalisée.

4 Cochez les cases correspondant aux éléments que vous souhaitez afficher dans les menus et dans les barres d’outils

de la perspective sélectionnée.

5 Cliquez sur OK.

6 Sélectionnez Fenêtre > Sauvegarder la perspective sous.

Dans la boîte de dialogue Sauvegarder la perspective sous, entrez le nouveau nom de la perspective, puis cliquez sur OK.

Lorsque vous enregistrez une perspective, Flash Builder ajoute le nom correspondant au menu Fenêtre > Ouvrir la perspective.

Suppression d’une perspective personnalisée

Vous pouvez supprimer des perspectives définies précédemment. Vous ne pouvez pas supprimer une perspective que vous n’avez pas créée.

1 Ouvrez la boîte de dialogue Préférences et sélectionnez Général > Perspectives.

2 Sous Perspectives disponibles, sélectionnez la perspective que vous souhaitez supprimer.

3 Cliquez sur Supprimer, puis sur OK.

Réinitialisation des perspectives

Vous pouvez restaurer la présentation originale d’une perspective après l’avoir modifiée.

1 Ouvrez la boîte de dialogue Préférences et sélectionnez Général > Perspectives.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

2 Sous Perspectives disponibles, sélectionnez la perspective à réinitialiser.

3 Cliquez sur Réinitialiser, puis sur OK.

Utilisation de vues

Déplacement et ancrage de vues

Vous pouvez déplacer les vues à l’intérieur du workbench, les ancrer à différents emplacements ou en annuler l’ancrage, en fonction de vos besoins.

1 Déplacez la vue vers l’emplacement souhaité en faisant glisser sa barre de titre.

Lorsque vous déplacez la vue dans le workbench, le curseur prend la forme d’une flèche noire pointant vers l’emplacement où la vue sera ancrée une fois le bouton de la souris relâché.

Vous pouvez faire glisser un groupe de vues empilées en cliquant sur l’espace vide situé à droite des onglets des vues et en déplaçant la souris.

Vous pouvez également déplacer une vue à l’aide de son menu contextuel. Ouvrez le menu contextuel à partir de l’onglet de la vue, sélectionnez Déplacer > Vue, déplacez la vue vers l’emplacement souhaité, puis cliquez de nouveau avec le bouton de la souris.

2 (Facultatif) Enregistrez les modifications en sélectionnant Fenêtre > Sauvegarder la perspective sous.

Réorganisation des onglets de vue

Outre l’ancrage des vues à différents emplacements du workbench, vous pouvez réorganiser les onglets des vues à l’intérieur d’un groupe de vues.

❖ Cliquez sur l’onglet de la vue à déplacer, faites glisser la vue vers l’emplacement souhaité, puis relâchez le bouton

de la souris. Un symbole représentant une pile apparaît lorsque vous faites glisser l’onglet d’une vue sur d’autres onglets.

Changement de vues

Le passage d’une vue à l’autre peut se faire de différentes façons :

• Cliquez sur l’onglet de la vue à laquelle vous souhaitez accéder.

• Sélectionnez une vue dans le menu Fenêtre de Flash Builder.

• Utilisez un raccourci clavier.

Utilisez Ctrl+F7 sous Windows ou Commande+F7 sous Macintosh. Appuyez sur la touche F7 pour sélectionner une vue.

Pour obtenir une liste de tous les raccourcis clavier, cliquez sur Aide > Assistant de touches.

Création et utilisation des vues rapides

Les vues rapides sont des vues masquées que vous pouvez ouvrir et fermer rapidement. Elles sont identiques aux autres vues à ceci près qu’elles n’encombrent pas le workbench.

Cliquez sur l’icône de vue rapide dans la barre de raccourcis pour afficher la vue. Cliquez à l’extérieur de la vue rapide (ou sur le bouton Réduire de sa barre d’outils) pour la masquer à nouveau.

Remarque : si vous convertissez la vue Explorateur de packages en vue rapide, puis ouvrez un fichier à partir de la vue rapide Explorateur de packages, la vue est automatiquement masquée pour vous permettre d’utiliser ce fichier.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Pour créer une vue rapide, procédez comme suit :

❖ Faites glisser la vue que vous souhaitez convertir en vue rapide vers la barre de raccourcis située dans l’angle

inférieur gauche de la fenêtre du workbench.

L’icône de la vue que vous avez déplacée apparaît dans la barre de raccourcis. Cliquez sur cette icône pour ouvrir la vue. Cliquez à l’extérieur de la vue pour la masquer.

Pour restaurer une vue rapide en vue normale, procédez comme suit :

❖ Dans le menu contextuel de la vue, désélectionnez Vue rapide.

Filtrage des vues Tâches et Erreurs

Vous pouvez filtrer les tâches ou les problèmes qui s’affichent dans les vues Tâches ou Erreurs. Par exemple, pour voir uniquement les erreurs que le workbench a consignées, ou les tâches que vous avez marquées comme rappel personnel, filtrez les éléments avec lesquels la ressource ou le groupe de ressources sont associés. Vous pouvez filtrer par chaîne de texte dans le champ Description, par gravité d’erreur, par priorité de tâche ou par état de tâche.

1 Dans la barre des tâches de la vue Tâches ou Erreurs, cliquez sur Filtrer.

2 Renseignez la boîte de dialogue Filtres, puis cliquez sur OK.

Pour plus d’informations sur les vues, voir « Utilisation de vues » à la page 19.

Editeurs Flash Builder

Le développement d’applications dans Flash Builder repose sur l’utilisation des éditeurs MXML, ActionScript 3.0 et CSS.

Les éditeurs sont associés à des types de ressource. Ainsi, lorsque vous ouvrez des ressources dans le workbench, l’éditeur correspondant s’affiche. Chaque éditeur intègre les fonctionnalités nécessaires au type de ressource donné.

Editeur MXML Utilisez l’éditeur MXML pour éditer le code MXML et pour incorporer un code ActionScript et CSS

dans les balises Source sert à l’édition du code. Le mode Création permet la mise en forme visuelle et la création des applications. Les deux modes sont synchronisés et les modifications effectuées dans un mode sont aussitôt répercutées dans l’autre mode.

Editeur ActionScript Utilisez l’éditeur ActionScript pour éditer des fichiers de classe et d’interface ActionScript. Vous

pouvez incorporer des fonctions ActionScript dans un fichier MXML à l’aide d’une balise de pratique courante de définir les classes dans des fichiers ActionScript distincts et d’importer ensuite les classes dans des fichiers MXML. Cette méthode vous permet de définir la plupart de vos applications dans ActionScript.

Editeur CSS Utilisez l’éditeur CSS pour afficher et éditer des feuilles de style en cascade. Vous pouvez ensuite appliquer

des styles aux éléments visuels de vos applications. Pour plus d’informations, voir Styles et thèmes.

Remarque : l’éditeur CSS est un éditeur à fonction unique pour les projets basés sur le SDK Flex 4. Pour les projets basés sur le SDK Flex 3, l’éditeur CSS comporte toutefois deux modes (Source et Création).

Voir aussi

« Outils de développement de code dans Flash Builder » à la page 48

<fx:Script> et <fx:Style. L’éditeur MXML propose deux modes : Source et Création. Le mode

<fx:Script>. Il est toutefois

Trucs et astuces concernant Flash Builder

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Utilisation de l’éditeur MXML en mode Création

Affichage du fichier MXML en mode Création

1 Si le fichier MXML n’est pas déjà ouvert dans l’éditeur MXML, double-cliquez sur le fichier dans l’Explorateur de

packages pour l’ouvrir.

2 Si l’éditeur MXML affiche le code source, cliquez sur Création dans la partie supérieure de la zone de l’éditeur.

Vous pouvez passer rapidement d’un mode à l’autre en appuyant sur les touches Ctrl+`(Guillemet ouvrant).

Le basculement entre les modes Source et Création affiche ou masque automatiquement les vues liées à la création, telles que Composants, Propriétés et Etats. Pour activer et désactiver ce comportement, accédez à la boîte de dialogue Préférences et sélectionnez Flash Builder > Editeurs > Mode Création et enfin l’option Afficher automatiquement les vues liées à la création.

Panoramique et défilement dans la zone de création

❖ Cliquez sur le bouton Mode Panoramique sur le côté droit de la barre d’outils de l’éditeur. Appuyez sur H pour

entrer en mode Panoramique à partir du clavier. Pour entrer temporairement en mode Panoramique, appuyez sur la barre d’espacement du clavier et maintenez-la enfoncée. Vous pouvez sélectionner ou déplacer des éléments en mode Panoramique.

Zoom dans la zone de création

Il existe plusieurs façons d’utiliser l’outil de zoom. Vous pouvez sélectionner des pourcentages dans le menu principal et le menu contextuel, cliquer sur le bouton Mode Zoom sur la barre d’outils ou utiliser des raccourcis clavier. Le pourcentage d’agrandissement en cours est toujours affiché dans la barre d’outils.

• Dans le menu principal, sélectionnez Création > Zoom avant ou Création > Zoom arrière. Vous pouvez également

sélectionner le sous-menu Agrandissement et choisir un pourcentage spécifique.

• Cliquez sur le bouton Mode Zoom dans la barre d’outils ou appuyez sur la touche Z du clavier. Un curseur de

symbole + s’affiche dans la zone de création.

• Sélectionnez un pourcentage dans le menu contextuel en regard des boutons Sélectionner, Panoramique et Mode

zoom de la barre d’outils de l’éditeur. La zone de création prend le pourcentage sélectionné ou s’ajuste à la taille de la fenêtre.

• Cliquez avec le bouton droit dans la zone de création pour sélectionner le sous-menu Zoom avant, Zoom arrière

ou Agrandissement. La zone de création change selon votre choix.

Vous pouvez recourir aux raccourcis clavier suivants dans la zone de création :

• Zoom avant : Ctrl+= (Commande+= sous Mac OS)

• Zoom arrière : Ctrl+- (Commande+- sous Mac OS)

Pour connaître d’autres raccourcis clavier, sélectionnez Aide > Assistant de touches.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Actualisation du mode Création pour un rendu correct

Vous pouvez le cas échéant actualiser le mode Création des éditeurs MXML et CSS pour rendre correctement la présentation. Le rendu de la présentation peut en effet dans certains cas devenir obsolète, par exemple si vous modifiez un élément visuel dans un composant Flash dépendant (SWC). Les styles et les habillages ne sont parfois pas rendus correctement, car Flash Builder doit régénérer le fichier.

❖ Cliquez sur le bouton Actualiser de la barre d’outils de l’éditeur.

Utilisation simultanée des modes Source et Création

Vous pouvez créer une vue partagée dans laquelle vous pourrez afficher les deux modes simultanément.

1 Dans le menu contextuel de l’onglet de l’éditeur, sélectionnez Nouvel éditeur.

Vous disposez à présent de deux onglets d’édition pour le même fichier.

2 Faites glisser l’un des onglets vers la droite pour le juxtaposer à l’autre onglet.

3 Configurez l’un des éditeurs en mode Création et l’autre éditeur en mode Source.

Pour afficher uniquement le mode Source en désactivant le mode Création, désélectionnez l’option Activer le mode Conception dans le menu Fenêtre.

Utilisation de composants visuels en mode Création MXML

L’éditeur MXML en mode Création vous permet d’utiliser les composants visuels pour avoir une idée de l’aspect de l’application aux différentes étapes de sa création. Vous pouvez également sélectionner, déplacer, redimensionner, faire défiler, agrandir ou faire un panoramique sur les éléments dans la zone de création. Cette approche est particulièrement utile lorsque vous avez des composants de type conteneur incorporés.

Utilisation de la vue Composants

La vue Composants s’affiche lorsque vous accédez au mode Création de l’éditeur MXML. Faites-en glisser les composants vers la zone de création pour définir la présentation de votre application.

Cette vue affiche par défaut les composants recommandés pour un projet. La version du SDK Flex d’un projet détermine quels composants sont répertoriés comme composants recommandés.

Par exemple, lors de la création d’un projet, Flash Builder utilise par défaut le SDK Flex 4.5. Les composants recommandés pour le SDK Flex 4.5 sont les composants Spark. Les composants MX ne possédant aucun équivalent Spark sont également répertoriés dans la liste des composants recommandés.

La vue Composants regroupe les composants en catégories, telles que Contrôles, Présentations, Navigateurs et Graphiques. La catégorie Personnaliser contient les composants définis dans des fichiers MXML et ActionScript distincts. Pour plus d’informations, voir « Création de composants MXML personnalisés » à la page 232.

Remarque : la vue Composants répertorie les composants visibles.

Modification de l’affichage des composants dans la vue Composants

Accédez au menu de la vue Composants pour en modifier l’affichage.

1 Pour afficher tous les composants, désélectionnez Afficher uniquement les composants recommandés.

En mode d’affichage de tous les composants, la vue regroupe les composants en composants Spark et MX.

2 Pour afficher les noms complets des classes, sélectionnez Afficher les noms qualifiés complets des classes.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Ajout de composants en mode Création MXML

1 En mode Création de l’éditeur MXML, ouvrez le fichier MXML dans lequel vous voulez insérer le composant.

Le fichier MXML doit être ouvert en mode Création pour que vous puissiez utiliser la vue Composants. Le fichier MXML peut être le fichier de l’application principale (fichier doté d’un conteneur Application) ou un fichier de composant MXML personnalisé.

2 Dans la vue Composants, localisez le composant à ajouter.

Si la vue n’est pas ouverte, sélectionnez Fenêtre > Composants.

La vue Composants classe les composants par catégories. Elle affiche également les composants recommandés pour un projet. Vous pouvez modifier les paramètres d’affichage de manière à obtenir la liste complète des composants. Pour plus d’informations, voir « Vue Composants » à la page 13.

3 Faites glisser un composant de la vue Composants vers le fichier MXML.

Le composant est placé en fonction de la règle de présentation du conteneur parent.

Sélection et déplacement de composants dans la zone de création

❖ Cliquez sur le bouton Mode Sélection (en forme de flèche) sur la droite de la barre d’outils de l’éditeur. Ce mode

est activé par défaut lorsque vous ouvrez un document. Appuyez sur la touche V du clavier pour passer en mode Sélection. Faites glisser et déposez un composant à l’emplacement souhaité. Vous pouvez aussi le faire glisser pour le redimensionner et cliquer dessus pour le sélectionner.

Sélection et désélection de plusieurs composants

Vous pouvez sélectionner plusieurs composants dans un fichier MXML. La sélection de plusieurs composants peut s’avérer utile si vous voulez définir une valeur commune pour une propriété partagée.

• Appuyez sur la touche Ctrl tout en cliquant sur (Commande-clic sous Macintosh) chaque composant de la

présentation

• Cliquez sur l’arrière-plan de la page et dessinez un rectangle chevauchant les composants.

• Dans la vue Structure (Fenêtre > Structure), appuyez sur la touche Ctrl tout en cliquant sur (Commande-clic sous

Macintosh) les composants dans le contrôle d’arborescence.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Pour désélectionner plusieurs composants, procédez comme suit :

• Cliquez sur le conteneur d’arrière-plan.

• Cliquez sur un composant désélectionné.

• Cliquez dans la marge grise encadrant le composant racine.

Positionnement des composants

Vous pouvez changer la position des composants visuellement en fonction de la propriété layout du conteneur parent. Si le conteneur parent spécifie que le positionnement est absolu, vous pouvez faire glisser les composants pour les repositionner. Dans le cas contraire, les composants repositionnés appliquent les règles de présentation du conteneur parent.

Par défaut, les conteneurs Spark font appel à la propriété BasicLayout qui autorise le positionnement absolu. Pour certains conteneurs MX, vous pouvez également définir la propriété layout sur voir MX layout containers.

Remarque : vous pouvez également utiliser des contraintes de présentation pour positionner un composant dans un conteneur. Ces contraintes définissent de quelle manière les composants doivent être repositionnés en cas de redimensionnement d’un conteneur. Elles permettent toutefois aussi d’en spécifier la position dans des conteneurs dont la taille est fixe. Voir Using constraints to control component layout.

absolute. Pour plus d’informations,

1 En mode Création de l’éditeur MXML, sélectionnez le composant dans la présentation et faites-le glisser vers une

nouvelle position.

Le composant est placé en fonction des règles de présentation du conteneur parent.

Si le conteneur bénéficie du positionnement absolu, vous pouvez faire glisser les composants et les positionner n’importe où dans le conteneur.

Par exemple, si vous déplacez un conteneur VGroup dans un conteneur HGroup, le conteneur VGroup est placé à l’horizontale avec les autres conteneurs enfant (s’ils existent).

2 En mode Création, sélectionnez le conteneur parent du composant et modifiez ses propriétés de présentation dans

la vue Propriétés.

Dans certains cas, vous pouvez changer la position des composants enfant en modifiant les propriétés du conteneur parent. Vous pouvez par exemple utiliser les propriétés l’espacement entre les composants enfant et la propriété

verticalGap et horizontalGap du conteneur pour définir

direction pour préciser une présentation à lignes ou à

colonnes.

Dimensionnement des composants

En mode Création, vous pouvez modifier la taille d’un composant en faisant glisser une poignée de redimensionnement, en utilisant le menu Création ou en modifiant ses propriétés dans la vue Propriétés.

Remarque : utilisez une présentation basée sur contrainte pour spécifier la manière dont un composant est redimensionné dynamiquement lors du redimensionnement d’un conteneur. Pour plus d’informations, voir Using constraints to control component layout.

Dimensionnement d’un composant visuellement

❖ En mode Création de l’éditeur MXML, cliquez sur le composant et faites glisser la poignée de dimensionnement

pour le redimensionner.

• Pour contraindre les proportions du composant, maintenez enfoncée la touche Maj tout en le faisant glisser.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

• Si l’alignement est activé, lorsque vous effectuez le redimensionnement, des lignes d’accrochage s’affichent pour

vous aider à aligner les bords du composant avec les composants voisins. Pour activer ou désactiver l’alignement dans le menu principal, sélectionnez > Activer l’accrochage.

Harmonisation de la largeur ou de la hauteur de deux composants ou plus

1 En mode Création, sélectionnez deux composants ou plus.

2 Dans le menu Création, sélectionnez l’une des options de dimensionnement suivantes :

Rendre de la même largeur Définit la propriété width de tous les composants sélectionnés sur celle du composant

que vous avez sélectionné en premier.

Rendre de la même hauteur Définit la propriété height de tous les composants sélectionnés sur celle du

composant que vous avez sélectionné en premier.

Si tous les composants sélectionnés se trouvent dans le même conteneur, et que le premier composant que vous sélectionnez a un pourcentage de largeur ou de hauteur spécifié, tous les éléments sont définis selon ce pourcentage. Dans le cas contraire, tous les composants sont définis avec la même largeur ou hauteur de pixel.

Dimensionnement d’un composant en modifiant ses propriétés

1 En mode Création, sélectionnez le composant.

Pour définir la taille de plusieurs composants simultanément, appuyez sur la touche Ctrl en cliquant (ou Maj-clic sous Mac OS) sur ces composants.

2 Dans la vue Propriétés (Fenêtre > Propriétés), définissez la propriété height ou width du ou des composants

sélectionnés.

La vue Propriétés propose trois vues pour l’affichage des propriétés d’un composant : une vue standard sous forme de formulaire, une vue par catégories sous forme de tableau et une vue alphabétique sous forme de tableau. Vous pouvez passer d’une vue à l’autre en cliquant sur les boutons correspondants dans la barre d’outils.

Utilisation de l’accrochage pour positionner les composants

Lorsque vous faites glisser visuellement un composant dans un conteneur doté du positionnement absolu, le composant peut s’accrocher dans la bonne position selon l’endroit vers lequel vous le faites glisser par rapport aux composants existants. Les composants peuvent s’aligner à la verticale ou à l’horizontale.

Vous pouvez désactiver l’accrochage pour un composant ou pour tous les composants.

Activation ou désactivation de l’accrochage

❖ Le fichier MXML étant ouvert en mode Création dans l’éditeur MXML, sélectionnez (ou désélectionnez) Création

> Activer l’accrochage.

Activation ou désactivation de l’accrochage dans les Préférences

1 Ouvrez la boîte de dialogue Préférences.

2 Sélectionnez Flash Builder > Editeurs > Mode Création dans le panneau latéral de la boîte de dialogue Préférences.

3 Sélectionnez ou désélectionnez l’option Activer l’accrochage.

absolute. Pour plus d’informations,

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Alignement de composants

Vous pouvez aligner visuellement les composants les uns par rapport aux autres dans un conteneur doté du positionnement absolu. Par défaut, les conteneurs Spark font appel à la propriété BasicLayout qui autorise le positionnement absolu. Pour certains conteneurs MX, vous pouvez également définir la propriété layout sur

absolute.

Vous pouvez également centrer les composants dans un conteneur grâce à une présentation basée sur des contraintes. Pour plus d’informations, voir Using constraints to control component layout.

Alignement de composants dans un conteneur doté du positionnement absolu

1 En mode Création de l’éditeur MXML, sélectionnez deux composants ou plus dans le conteneur.

Pour plus d’informations, voir « Sélection et désélection de plusieurs composants » à la page 23.

2 Sélectionnez l’une des options d’alignement suivantes dans le menu Création :

Aligner à gauche Positionne tous les composants sélectionnés de manière que leur bord gauche s’aligne avec le

bord du premier composant que vous avez sélectionné.

Aligner les centres à la verticale Positionne tous les composants sélectionnés de manière que leur centre s’aligne à

la verticale avec celui du premier composant que vous avez sélectionné.

Aligner à droite Positionne tous les composants sélectionnés de manière que leur bord droit s’aligne avec le bord

du premier composant que vous avez sélectionné.

Aligner en haut Positionne tous les objets sélectionnés de manière que leur bord supérieur s’aligne avec le bord du

premier composant que vous avez sélectionné.

Aligner les centres à l’horizontale Positionne tous les composants sélectionnés de manière que leur centre s’aligne

à l’horizontale avec celui du premier composant que vous avez sélectionné.

Aligner en bas Positionne tous les composants sélectionnés de manière que leur bord inférieur s’aligne avec le bord

du premier composant que vous avez sélectionné.

Aligner les lignes de base Positionne tous les composants sélectionnés de manière que leur ligne de base de texte

horizontal s’aligne avec la ligne de base de texte du premier composant que vous avez sélectionné. Pour les composants dépourvus de ligne de base de texte (tels que HGroup), le bord inférieur est considéré comme la ligne de base.

Pour les objets dépourvus de contraintes de présentation, Flash Builder ajuste la propriété l’alignement vertical et la propriété

y pour modifier l’alignement horizontal.

x pour changer

Pour les objets dépourvus de contraintes de présentation, Flash Builder ajuste les contraintes gauche et droite pour changer l’alignement vertical et les contraintes de haut et bas pour modifier l’alignement horizontal. Seules les contraintes existantes sont modifiées, aucun nouvelle contrainte n’est ajoutée.

Supposons, par exemple, que le composant A possède une contrainte gauche et aucune contrainte droite, et que le composant B soit doté d’une contrainte gauche et d’une droite. Si vous sélectionnez les composants A et B et que vous sélectionnez Création > Aligner les centres à la verticale, Flash Builder ajuste la contrainte gauche de l’objet A et les contraintes gauche et droite de l’objet B pour les aligner. La contrainte de droite non spécifiée de l’objet A reste non spécifiée.

Ajustement de composants

Vous pouvez ajuster la position de composants dans un conteneur doté du positionnement absolu en les déplaçant d’un ou de dix pixels à la fois en utilisant les touches de direction.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Ajustement des composants d’un pixel

❖ Sélectionnez un ou plusieurs composants en mode Création de l’éditeur MXML et appuyez sur l’une des touches

de direction.

Ajustement des composants de dix pixels

❖ Sélectionnez un ou plusieurs composants en mode Création de l’éditeur MXML et appuyez sur l’une des touches

de direction tout en maintenant la touche Maj enfoncée.

Maintenez la touche de direction enfoncée pour continuer à déplacer le composant.

Masquage des bordures de conteneurs

Flash Builder affiche par défaut les bordures des conteneurs en mode Création de l’éditeur MXML. Vous pouvez toutefois les masquer.

❖ Sélectionnez Création > Afficher les bordures des conteneurs.

Cette commande est un bouton bascule. Sélectionnez-la à nouveau pour afficher les bordures.

Définition des propriétés des composants

Vous pouvez définir visuellement les propriétés de composants dans la zone de création ou dans la vue Propriétés.

Modification du texte affiché par un composant

❖ Pour éditer le texte affiché par un composant tel qu’un contrôle Label ou TextInput, double-cliquez sur le

composant et saisissez vos modifications.

Changement du texte dans le champ ID

Lorsque vous modifiez du texte dans le champ ID, vous êtes invité à mettre à jour toutes les références de l’espace de travail avec le nouvel identifiant. Vous pouvez définir la suppression de cette boîte de dialogue à la page Mode Création des Préférences :

1 Ouvrez la fenêtre Préférences.

2 Sélectionnez Flash Builder > Editeurs > Mode Création.

3 Sélectionnez ou désélectionnez Toujours mettre à jour les références lors de la modification des ID dans la vue

Propriétés.

Définition des autres propriétés d’un composant

❖ Sélectionnez un composant et définissez-en les propriétés dans la vue du même nom (Fenêtre > Autres vues > Flash

Builder > Propriétés).

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Vue Propriétés d’un composant DataGrid

Pour définir les propriétés dans la Vue par catégories ou dans la Vue alphabétique, cliquez sur les boutons correspondant aux vues dans la barre d’outils.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Vue par catégories pour un composant Button

Remarque : pour appliquer votre dernière modification, appuyez sur la touche Entrée ou de tabulation, ou cliquez en dehors de la vue.

Copie de composants dans d’autres fichiers MXML

Vous pouvez copier et coller visuellement des composants d’un fichier MXML vers un autre.

1 Vérifiez que les deux fichiers MXML sont ouverts en mode Création de l’éditeur MXML.

2 Sélectionnez des composants dans l’un des fichiers. Cliquez ensuite sur Editer > Copier.

3 Accédez à l’autre fichier, cliquez à l’intérieur d’un conteneur et sélectionnez Editer > Coller.

Suppression de composants

Vous pouvez supprimer des composants de l’interface utilisateur. Sélectionnez un composant, puis procédez de l’une des manières suivantes :

• Appuyez sur la touche de suppression de votre clavier.

• Dans le menu contextuel du composant, sélectionnez Supprimer.

• Dans le menu Editer de Flash Builder, sélectionnez Supprimer.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Inspection de la structure de votre MXML

La vue Structure (Fenêtre > Structure) en mode Création permet d’examiner la structure de l’application et de sélectionner un ou plusieurs composants. Lorsque vous avez plusieurs états d’affichage, la vue Structure affiche la structure de l’état d’affichage actif.

1 Le fichier MXML étant ouvert en mode Création, sélectionnez la vue Structure.

2 Dans la vue Structure, sélectionnez un ou plusieurs composants.

Ces composants apparaissent également sélectionnés en mode Création de l’éditeur.

En mode Source, seul le premier composant sélectionné dans la vue Structure apparaît comme étant sélectionné dans l’éditeur.

Voir aussi

Conseils et astuces pour Flash Builder (article du Pôle de développement)

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Utilisation de composants visuels en mode Source MXML

En mode Source de l’éditeur MXML, l’assistant de contenu vous aide lors de l’ajout de conteneurs et de contrôles Flex standard à l’interface utilisateur.

L’exemple suivant illustre comment utiliser l’assistant de contenu pour insérer un conteneur conteneur à celle de

1 Ouvrez un fichier MXML en mode Source dans l’éditeur MXML.

<s:HGroup>. HGroup étant un composant Spark, l’assistant privilégie l’utilisation d’un conteneur VGroup

<mx:VBox>.

<s:VGroup> dans un

Le fichier MXML peut être le fichier de l’application principale (fichier doté d’un conteneur Application) ou un fichier de composants MXML personnalisés.

2 Placez le point d’insertion dans la balise de conteneur parent.

Pour insérer par exemple un conteneur VGroup dans un conteneur parent HGroup, placez le point d’insertion après la balise d’ouverture

<s:HGroup> insertion point here </s:HGroup>

3 Saisissez la balise du composant.

<s:HGroup>.

En cours de saisie, l’assistant de contenu s’affiche pour vous suggérer des entrées possibles. Les composants recommandés s’affichent en noir. Les composants non recommandés s’affichent en gris.

Dans cet exemple, VGroup est recommandé, contrairement à VBox qui ne l’est pas.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

4 Appuyez le cas échéant sur les touches représentant des flèches pour sélectionner une balise dans le menu, puis

appuyez sur Entrée.

Outre les composants standard, l’assistant de contenu répertorie les composants personnalisés que vous avez définis dans des fichiers MXML et ActionScript distincts et que vous avez enregistrés dans le projet en cours ou dans son chemin source.

L’assistant de contenu peut également suggérer des propriétés, des événements, des effets et des styles. Appuyez sur les touches Ctrl+Espace pour parcourir les recommandations de l’assistant de contenu.

Vous pouvez modifier le type et l’ordre des recommandations de l’assistant de contenu. Dans la boîte de dialogue Préférences, sélectionnez Flash Builder > Editeurs > Code MXML > Avancées.

Voir aussi

« Assistant de contenu » à la page 48

« Création de composants MXML personnalisés » à la page 232

Association d’éditeurs à des types de fichier

Le workbench permet d’associer les éditeurs avec différents types de fichiers.

1 Sélectionnez Fenêtre > Préférences.

2 Cliquez sur le signe plus pour développer la catégorie Général.

3 Cliquez sur le signe plus pour développer la catégorie Editeurs, puis sélectionnez Associations de fichiers.

4 Sélectionnez un type de fichier dans la liste Types de fichier.

Pour ajouter un type de fichier à la liste, cliquez sur Ajouter, entrez le nouveau type de fichier dans la boîte de dialogue Ajouter un type de fichier, puis cliquez sur OK.

5 Dans la liste Editeurs associés, sélectionnez l’éditeur à associer à ce type de fichier.

Pour ajouter à la liste un éditeur interne ou externe, cliquez sur Ajouter et renseignez la boîte de dialogue.

6 Cliquez sur OK.

Vous pouvez modifier les préférences par défaut de l’éditeur à partir du menu contextuel de toute ressource se trouvant dans l’une des vues de navigation. Dans le menu contextuel, sélectionnez Ouvrir avec.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Edition de fichiers en dehors du workbench

Vous pouvez éditer un fichier MXML ou ActionScript dans un éditeur externe puis l’utiliser dans Flash Builder. Le workbench effectue les opérations de création ou d’actualisation nécessaires afin d’appliquer les modifications que vous avez apportées au fichier en dehors du workbench.

Actualisation d’un fichier MXML ou ActionScript édité en dehors du workbench

1 Editez le fichier MXML ou ActionScript dans l’éditeur externe de votre choix.

2 Enregistrez et fermez le fichier.

3 Démarrez Flash Builder.

4 Dans l’une des vues de navigation du workbench, ouvrez le menu contextuel, puis sélectionnez Actualiser.

Si vous utilisez régulièrement des éditeurs externes, vous pouvez activer l’actualisation automatique. Pour ce faire,

sélectionnez Fenêtre > Préférences, développez la catégorie Général, sélectionnez Espace de travail, puis cochez l’option Actualiser automatiquement. Lorsque vous activez cette option, le workbench consigne toutes les modifications externes apportées au fichier. La vitesse de l’actualisation automatique dépend de votre plateforme.

Mosaïque d’éditeurs

Le workbench vous permet d’ouvrir plusieurs fichiers dans différents éditeurs. Mais contrairement aux vues, les éditeurs ne peuvent pas être déplacés à l’extérieur du workbench pour créer des fenêtres. Vous pouvez cependant disposer les éditeurs en mosaïque dans la zone d’édition afin d’afficher les fichiers source côte à côte.

1 Ouvrez deux ou plusieurs fichiers dans la zone d’édition.

2 Cliquez sur l’onglet de l’un des éditeurs.

3 Faites-le glisser vers le bord gauche, droit, supérieur ou inférieur de la zone d’édition.

Le pointeur prend la forme d’une flèche noire pointant vers l’emplacement où la vue est ancrée une fois le bouton de la souris relâché.

4 (Facultatif) Faites glisser les bords des éditeurs pour les redimensionner, si besoin est.

Agrandissement d’une vue ou d’un éditeur

Vous pouvez procéder de différentes façons pour agrandir (restaurer) une vue ou un éditeur de manière à occuper entièrement la fenêtre du workbench.

• Accédez au menu contextuel de la barre de titre de la vue ou de l’éditeur et sélectionnez Agrandir (Restaurer).

• Double-cliquez sur l’onglet de la vue.

• Dans le menu Fenêtre de Flash Builder, sélectionnez Agrandir/Rétablir l’éditeur.

• Cliquez sur les icônes Agrandir/Restaurer situées dans l’angle supérieur droit de la vue ou de l’éditeur.

Projets dans Flash Builder

Flash Builder regroupe les ressources (dossiers et fichiers) qui constituent une application dans un conteneur appelé project.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

La vue Explorateur de packages vous permet de gérer les projets, en ajoutant, modifiant et supprimant des ressources. Vous pouvez également fermer les projets à l’intérieur d’un espace de travail, importer des ressources et créer des liens vers des ressources externes.

Types de projets

Flash Builder prend en charge les différents types de projets, selon le type d’application que vous créez.

Projets Flex

Utilisez un projet Flex pour créer une application Web ou de bureau qui est basée sur la structure Flex. Une application Web s’exécute dans Adobe Flash Player, tandis qu’une application de bureau s’exécute dans Adobe AIR. Lorsque vous créez le projet, vous indiquez s’il est destiné aux applications Web ou de bureau.

Un projet Flex contient un ensemble de propriétés qui contrôlent la façon dont l’application est générée, l’endroit où l’application construite est hébergée, la manière dont le débogage est géré et les relations avec les autres projets de l’espace de travail.

Un projet Flex contient un fichier d’application MXML par défaut. Les autres fichiers MXML du projet peuvent également servir de fichiers d’application.

Voir « Création de projets Flex » à la page 88 et « Développement d’applications avec Flex » à la page 181.

Projets Flex mobiles

Utilisez un projet Flex mobile pour créer une application AIR destinée à la plateforme mobile. L’application repose sur la structure Flex. Vous pouvez utiliser Flash Builder pour afficher un aperçu, déboguer et profiler les applications mobiles à partir du bureau ou sur un périphérique.

Un projet Flex mobile comporte un seul fichier d’application MXML par défaut. En général, une application mobile comporte un jeu de composants Vue qui affichent le contenu d’un périphérique. Le fichier d’application MXML par défaut lance le composant Vue par défaut.

Flash Builder utilise AIR Debug Launcher (ADL) pour afficher un aperçu des applications mobiles sur le bureau. Bien qu’il ne s’agisse pas d’une vraie émulation, ADL vous permet de voir la mise en forme et le comportement de l’application, en proposant des options pour faire tourner l’application.

Vous pouvez afficher un aperçu de l’application mobile sur un périphérique connecté au port USB de l’ordinateur de développement. Lorsque vous affichez un aperçu sur un périphérique, Flash Builder exporte l’application sur le périphérique.

Voir « Création de projets Flex mobiles » à la page 90 et Développement d’applications mobiles avec Flex et Flash

Builder.

Projets ActionScript

Utilisez un projet ActionScript pour créer des applications Web ou de bureau qui reposent sur les API de Flash ou d’Adobe AIR. Lorsque vous créez le projet, vous indiquez s’il est destiné à une application Web ou de bureau.

Ces projets ne faisant pas appel à MXML pour définir une interface utilisateur, vous ne pouvez pas afficher la mise en forme et la conception de l’application en mode Création. Vous travaillez exclusivement dans l’éditeur source, les outils de débogage selon les besoins, puis créez le projet dans des fichiers SWF pour afficher un aperçu de votre application et la tester.

Lorsque vous créez un projet ActionScript ou un fichier ActionScript autonome destiné à contenir des fonctions, une classe ou une interface, la perspective de développement Flex change pour prendre en charge l’éditeur ActionScript. Les principales vues associées à l’éditeur ActionScript sont les vues Structure et Erreurs.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Voir « Création de projets ActionScript » à la page 91.

Projets ActionScript mobiles

Utilisez un projet ActionScript mobile pour créer des applications mobiles qui reposent sur l’API d’Adobe AIR. Lorsque vous créez le projet, vous spécifiez une plateforme mobile cible et certains paramètres d’applications mobiles. Vous pouvez utiliser Flash Builder pour afficher un aperçu de l’application mobile à partir du bureau ou sur un périphérique.

Flash Builder utilise AIR Debug Launcher (ADL) pour afficher un aperçu, déboguer et profiler des applications mobiles sur le bureau. Bien qu’il ne s’agisse pas d’une vraie émulation, ADL vous permet de voir la mise en forme et le comportement de l’application, en proposant des options pour faire tourner l’application.

Voir « Création de projets ActionScript mobiles » à la page 91.

Projets de bibliothèque Flex

Utilisez un projet de bibliothèque Flex pour créer des bibliothèques de code personnalisées à partager entre les applications ou à distribuer à d’autres développeurs. En règle générale, vous utilisez les projets de bibliothèque pour assembler et distribuer les composants et ressources à d’autres développeurs.

Un projet de bibliothèque génère un fichier SWC, c’est-à-dire un fichier archive pour les composants Flex ainsi que pour d’autres ressources.

Voir « Utilisation de projets de bibliothèque Flex » à la page 227.

Projets compatibles avec Flash Catalyst

Utilisez un projet compatible avec Flash Catalyst si vous prévoyez de partager des fichiers de projet avec des projets Adobe Flash Catalyst. Cette fonctionnalité permet aux créateurs et développeurs de collaborer et de travailler ensemble sur le même projet.

Voir « Création de projets compatibles avec Flash Catalyst » à la page 92.

Projets Flash Professional

Utilisez un projet Flash Professional pour modifier, créer ou déboguer des fichiers FLA ou XFL créés dans Adobe Flash Professional. Cette fonctionnalité permet aux développeurs Flash Professional de profiter de l’environnement de modification et de débogage que fournit Flash Builder. Les projets Flash Professional sont disponibles dans Flash Builder uniquement si vous avez installé Flash Professional.

Voir « Utilisation de Flash Builder avec Flash Professional » à la page 245.

Gestion de projets

L’Explorateur de packages permet d’ajouter des ressources à un projet, d’importer des ressources, d’exporter des projets ainsi que de déplacer et de supprimer des ressources.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Projets dans l’Explorateur de packages

Tous les projets d’un espace de travail s’affichent dans l’Explorateur de packages, comme l’illustre l’exemple suivant. L’Explorateur de packages présente une arborescence des projets dans une vue à la fois physique et logique (plate). Cette vue vous permet de gérer les projets en ajoutant et en supprimant des ressources (dossier et fichiers), en important des ressources externes et en créant des liens vers ces ressources ainsi qu’en déplaçant les ressources vers d’autres projets dans l’espace de travail.

Principales caractéristiques de l’Explorateur de packages :

• L’affichage des packages ActionScript peut se présenter de manière hiérarchique ou plate.

Utilisez le menu de l’Explorateur de packages pour spécifier la présentation des packages.

• Les bibliothèques de projet sont représentées dans deux nœuds de niveau supérieur : un nœud pour le SDK Flex et

l’autre pour les bibliothèques référencées.

Vous pouvez développer le contenu d’une bibliothèque et ouvrir les éditeurs pour afficher les pièces jointes.

• Les symboles d’erreur et d’avertissement apparaissant au niveau des nœuds de l’Explorateur de packages signalent

d’éventuels problèmes dans un package.

• Vous pouvez restreindre les projets et ressources visibles.

Vous pouvez créer un jeu de documents (collection de ressources), définir des filtres d’affichage et trier les ressources par nom et type. Ces options sont disponibles dans les menus de l’Explorateur de packages. Pour plus d’informations sur la modification des vues, voir « Personnalisation du workbench » à la page 259.

• Vous pouvez développer les fichiers ActionScript, MXML et CSS ainsi qu’afficher leur contenu sous forme

d’arborescence.

Dans l’Explorateur de packages, vous pouvez ouvrir les ressources du projet pour les modifier. Vous pouvez par exemple modifier les codes MXML et ActionScript dans les blocs

<fx:Style>. Vous pouvez également passer en mode Création et agencer visuellement les composants et les contrôles

<fx:Script> et le code CSS dans les blocs

pour définir la présentation de l’application et son comportement. Pour plus d’informations sur l’utilisation des éditeurs Flash Builder, voir « Editeurs Flash Builder » à la page 20 et « Création d’interfaces utilisateur » à la page 182.

Ensuite, vous ajoutez des projets, des fichiers et des dossiers, puis vous les organisez et gérez selon vos besoins. Voir « Projets dans Flash Builder » à la page 33.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

La plupart des commandes de menu que vous utilisez dans la vue Explorateur de packages sont également disponibles dans le menu contextuel de la vue.

Voir aussi

« Gestion de projets » à la page 35

« Ressources des projets » à la page 40

Déplacement d’un projet d’un espace de travail vers un autre

Vous pouvez faire appel à une association d’opérations de suppression et d’importation pour déplacer un projet d’un espace de travail vers un autre. Lorsque vous supprimez un projet d’un espace de travail, vous pouvez l’effacer de l’espace de travail mais le laisser dans le système de fichiers (voir « Suppression de projets » à la page 37). Après avoir supprimé un projet d’un espace de travail, vous pouvez l’importer dans un autre.

Spécification du SDK d’un projet

Lorsque vous créez un projet Flex, vous pouvez spécifier quel SDK Flex vous souhaitez utiliser. Les paramètres du SDK pourront être modifiés ultérieurement en cliquant sur Projet > Propriétés > Compilateur Flex > Utiliser un SDK spécifique.

Vous pouvez compiler un projet en utilisant un SDK Flex qui n’est pas disponible dans votre installation Flash Builder en le téléchargeant et en l’y ajoutant. Par exemple, téléchargez le SDK et ajoutez-le à Flash Builder à l’aide de la commande Projet > Propriétés > Compilateur Flex > Configurer les SDK Flex.

Suppression de projets

Lorsque vous supprimez un projet, vous le retirez de l’espace de travail en cours. Vous pouvez également le supprimer simultanément du système de fichiers.

Au lieu de supprimer le projet de l’espace de travail, vous pouvez le fermer. La fermeture du projet vous permet de conserver une référence à ce projet dans l’espace de travail tout en libérant des ressources système. Pour plus d’informations, voir « Fermeture et ouverture de projets » à la page 37.

1 Dans l’Explorateur de packages, sélectionnez le projet à supprimer.

2 Dans le menu principal, sélectionnez Editer > Supprimer.

3 Sélectionnez une option.

Supprimer également le contenu sous le répertoire Supprime définitivement le projet de l’espace de travail et du

système de fichiers.

Ne pas supprimer le contenu Supprime le projet de l’espace de travail sans le supprimer du système de fichiers.

Fermeture et ouverture de projets

Pour économiser de la mémoire et accélérer la génération sans supprimer un projet, vous pouvez le fermer. Lorsque vous fermez un projet, vous réduisez le projet et ses ressources, mais son nom reste visible dans l’Explorateur de packages. Un projet fermé nécessite moins de mémoire qu’un projet ouvert et est exclu des générations. Vous pouvez facilement rouvrir un projet fermé.

1 Dans l’Explorateur de packages, sélectionnez le projet à fermer ou rouvrir.

2 Dans le menu contextuel de l’Explorateur de packages, sélectionnez Fermer le projet ou Ouvrir le projet.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Changement du fichier de l’application principale

Lorsque vous créez un projet Flex, un fichier de l’application principale est créé. Par défaut, il est nommé d’après le projet. Le fichier de l’application principale est le point d’accès à vos applications et est la base du fichier SWF de l’application. Cependant, à mesure que vous ajoutez des fichiers à l’application, vous pouvez désigner un fichier différent comme fichier de l’application principale.

Si vous préférez définir plusieurs fichiers d’application de manière à ce que chaque fichier d’application soit généré dans un fichier SWF distinct, consultez « Gestion des fichiers d’application du projet » à la page 38.

1 Dans l’Explorateur de packages, sélectionnez le fichier d’application MXML que vous voulez définir comme fichier

de l’application principale.

2 Dans le menu contextuel de l’Explorateur de packages, sélectionnez Définir comme application par défaut.

Vous pouvez gérer les fichiers d’application du projet en sélectionnant Projet > Propriétés > Applications Flex (ou Applications ActionScript si vous utilisez un projet ActionScript).

Gestion des fichiers d’application du projet

Un projet possède généralement un seul fichier de l’application principale, qui sert de point d’accès à l’application. Le compilateur Flash Builder utilise ce fichier pour générer le fichier d’application SWF.

Une application complexe peut par exemple être dotée de nombreux composants MXML personnalisés qui représentent des éléments d’application distincts mais interdépendants. Vous pouvez créer un fichier d’application contenant un composant personnalisé et ensuite le générer, l’exécuter et le tester séparément.

Par défaut, vous pouvez exécuter l’application à chaque ajout d’un fichier d’application MXML au projet Flex. Ce fichier est alors ajouté à la liste des fichiers d’application du projet. Tous les fichiers définis comme fichiers d’application doivent se trouver dans le dossier source du projet.

Vous pouvez gérer la liste des fichiers d’application en sélectionnant un projet et en affichant ses propriétés.

1 Dans l’Explorateur de packages, sélectionnez un projet.

2 Sélectionnez Projet > Propriétés dans le menu principal ou sélectionnez Propriétés dans le menu contextuel.

3 Dans la boîte de dialogue Propriétés du projet, sélectionnez Applications Flex (ou Applications ActionScript si vous

utilisez un projet ActionScript).

4 Ajoutez et supprimez les fichiers d’applications selon vos besoins. Cliquez sur OK.

Changement de l’espace de travail

Vous ne pouvez travailler que dans un seul espace de travail à la fois. Lorsque vous installez et exécutez Flash Builder pour la première fois, un message vous invite à créer un espace de travail qui devient l’espace de travail par défaut. Vous pouvez créer d’autres espaces de travail et passer de l’un à l’autre en sélectionnant l’espace de travail voulu au lancement de Flash Builder ou en choisissant Fichier > Commuter l’espace de travail.

Définition des propriétés des projets Flex

Chaque projet Flex possède son propre jeu de propriétés. Pour définir ces propriétés, sélectionnez le projet dans la vue Explorateur de packages. Dans le menu principal, sélectionnez ensuite Projet > Propriétés. Vous pouvez également accéder aux propriétés à partir du menu contextuel du projet.

Vous pouvez définir les préférences de projet suivantes.

Ressource Présente des informations générales concernant le projet, les paramètres pour le codage de texte et les

délimiteurs de lignes du système d’exploitation.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Générateurs Précise l’outil de génération à utiliser. Flash Builder contient un outil de génération standard. Vous

pouvez faire appel à Apache Ant (outil de génération « open source ») pour créer des scripts de génération ou importer des scripts de génération Ant existants

Voir « Personnalisation des générations avec Apache Ant » à la page 110.

Modèle de données La configuration du modèle de données est uniquement disponible avec LiveCycle Data Services

version 3 ou supérieure. Elle spécifie l’emplacement du fichier du modèle de données contenant les informations sur le type de service et de données pour LiveCycle Data Services.

Données/Services Pour les projets accédant à des services de données, cette page définit si le générateur de code par

défaut doit être utilisé pour accéder aux services. Vous pouvez également indiquer si vous souhaitez utiliser une seule occurrence de serveur pour accéder aux services.

Pour plus d’informations sur l’extension de Flash Builder de manière à prendre en charge la génération de code personnalisé, voir Extension de la prise en charge des services dans Flash Builder.

Pour plus d’informations sur l’utilisation d’une seule instance de serveur lors de l’accès aux services, voir Utilisation d’une occurrence de serveur unique.

Applications Flex Affiche le nom des fichiers de projet définis comme fichiers d’application pouvant être compilés,

débogués et exécutés en tant qu’applications distinctes

Voir « Gestion des fichiers d’application du projet » à la page 38.

Chemin de génération Flex Spécifie le chemin d’accès à la génération, qui précise l’emplacement des fichiers source

externes et des fichiers de bibliothèque. Vous pouvez modifier ce chemin et changer le nom du dossier de sortie

(voir « Définition d’un dossier de sortie de projet » à la page 106 et « Création manuelle de projets » à la page 108).

Compilateur Flex Spécifie d’une part les préférences optionnelles pour le compilateur (génération d’un fichier SWF

accessible, activation des avertissements de compilation et de la vérification des types, spécification d’arguments de compilation supplémentaires et définition de la version du SDK Flex) et définit d’autre part les paramètres de l’enveloppe HTML

(voir « Options de génération avancées » à la page 108).

Modules Flex Précise les modules à générer et à optimiser pour le projet. Pour plus d’informations sur l’utilisation des

modules dans Flash Builder, voir « Création d’un projet distinct pour les modules dans Flash Builder » à la page 237.

Serveur Flex Spécifie le type de serveurs d’applications pour le projet. A la création d’un projet, vous avez la possibilité

de spécifier un type de serveurs d’applications. Vous pouvez modifier ce type ici. Si vous modifiez le type de serveurs d’applications d’un projet, vous risquez de ne plus pouvoir accéder aux services de données précédemment configurés.

Voir « Création de projets Flex » à la page 88 et Création d’un projet Flex pour l’accès à des services de données.

Thème Flex Spécifie le thème à utiliser pour toutes les applications du projet. Vous pouvez spécifier l’un des thèmes

disponibles dans Flash Builder ou en importer un.

Voir « Application des thèmes » à la page 187.

Références de projet Répertorie les projets auxquels le projet en cours fait référence.

Exécuter/déboguer les paramètres Gère les paramètres de configuration de lancement.

Voir « Gestion des configurations de lancement » à la page 120.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Création de jeux de documents

Si votre espace de travail contient de nombreux projets, vous pouvez créer un jeu de documents afin de regrouper un certain nombre de projets. Vous pouvez alors afficher des jeux de documents différents dans les vues Explorateur de packages et Tâches ainsi que limiter la portée de vos recherches à des jeux de documents (et éviter donc les recherches portant sur l’ensemble de l’espace de travail).

Création d’un jeu de documents

1 Dans la vue Explorateur de packages, ouvrez le menu de la barre d’outils et choisissez Sélectionner un jeu de

documents.

2 Sélectionnez Nouveau.

Flash Builder propose deux types de jeu : les points d’arrêt (utilisés lors du débogage) et les ressources.

3 Sélectionnez le type Ressource, puis cliquez sur Suivant.

4 Entrez le nom du jeu de documents, puis choisissez les projets de l’espace de travail que vous souhaitez inclure dans

le jeu.

5 Cliquez sur Terminer.

Le jeu de documents est aussitôt appliqué à la vue Explorateur de packages et seuls les projets et les ressources qui figurent dans le jeu s’affichent.

Affichage de tous les projets dans l’espace de travail

❖ Dans la vue Explorateur de packages, ouvrez le menu de la barre d’outils et choisissez Désélectionner le jeu de

documents.

Ressources des projets

Les projets sont constitués de ressources (dossiers et fichiers) que vous pouvez gérer depuis l’Explorateur de packages. Les projets sont contenus dans un espace de travail. L’Explorateur de packages propose une représentation logique de l’espace de travail dans le système de fichiers. Il est actualisé à chaque fois que vous ajoutez, supprimez ou modifiez une ressource.

Vous pouvez également modifier les ressources du projet directement dans le système de fichiers, sans passer par Flash Builder ni par l’Explorateur de packages.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Création de fichiers dans un projet

Une application dans Adobe® Flex® est généralement composée d’un fichier d’application MXML, d’une ou plusieurs vues (projets mobiles uniquement) et d’un ou plusieurs composants Flex standard. Vous pouvez également avoir un ou plusieurs composants définis dans divers fichiers MXML, ActionScript ou de composant Flash (SWC). En scindant l’application en blocs de dimensions maniables, vous pouvez rédiger et tester chaque composant individuellement. Dans un souci d’efficacité, les composants peuvent être réutilisés, dans la même application ou dans une application différente.

Vous pouvez utiliser Adobe Flash® Builder™ pour créer des composants MXML et ActionScript personnalisés, puis les intégrer à vos applications. Pour plus d’informations sur la création de composants ActionScript, voir « Création d’une

classe ActionScript » à la page 42.

Vous pouvez également créer un composant MXML directement à partir de code. Pour plus d’informations, voir Simple MXML Components.

Création d’un fichier

1 Dans l’Explorateur de packages, sélectionnez Fichier > Nouveau > Fichier.

2 Si l’espace de travail contient plusieurs projets, sélectionnez le projet auquel vous voulez ajouter le fichier.

3 Entrez le nom du fichier, puis cliquez sur Terminer.

Vous pouvez également ajouter des dossiers et des fichiers se trouvant en dehors du projet en cours. Pour plus d’informations, voir « Liaison à des ressources situées en dehors de l’espace de travail du projet » à la page 44.

Création de fichiers d’application MXML

1 Dans l’Explorateur de packages, sélectionnez le projet auquel vous souhaitez ajouter le fichier d’application MXML.

2 Dans le menu contextuel de l’Explorateur de packages, sélectionnez Nouveau > Application MXML.

3 Le fichier d’application est créé dans le dossier src par défaut. Vous pouvez sélectionner un autre dossier du projet,

le cas échéant.

4 Indiquez le nom du fichier d’application et sélectionnez une présentation Spark, si nécessaire. Pour plus

d’informations à propos des présentations Spark, voir A propos des présentations Spark

5 Les options suivantes s’appliquent uniquement aux projets mobiles :

a Spécifiez un ID d’application.

b Spécifiez le modèle d’application.

Voir Modèles d’applications mobiles.

c Spécifiez les droits des applications mobiles pour la plateforme Google Android.

Voir Droits des applications mobiles.

d Spécifiez les paramètres de plateforme.

Voir Paramètres de plateforme

e Spécifiez les paramètres d’application.

Voir Paramètres d’application.

6 Cliquez sur Terminer.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Création d’une classe ActionScript

Vous pouvez faire appel à un assistant Flash Builder pour créer rapidement des classes ActionScript pour les projets Flex et ActionScript. Cet assistant vous permet également de générer facilement des stubs pour des fonctions devant être implémentées.

1 Sélectionnez Fichier > Nouveau > Classe ActionScript.

2 Dans la boîte de dialogue, spécifiez les propriétés de base de la nouvelle classe, puis cliquez sur Terminer.

Une fois que vous avez cliqué sur Terminer, Flash Builder enregistre le fichier dans le package spécifié et le rouvre dans l’éditeur de code.

Si vous avez enregistré le fichier dans le projet actif ou dans le chemin source correspondant, Flash Builder affiche également le composant dans la vue Composants pour permettre son insertion rapide dans les applications. Pour plus d’informations, voir « Ajout de composants en mode Création MXML » à la page 23.

3 Rédigez la définition de la classe ActionScript.

Pour plus d’informations, voir Création de composants visuels simples dans ActionScript.

Création d’une interface ActionScript

Vous pouvez faire appel à un assistant Flash Builder pour créer rapidement des interfaces ActionScript pour les projets Flex et ActionScript. Une interface est un ensemble de constantes et de méthodes que différentes classes peuvent partager.

1 Sélectionnez Fichier > Nouveau > Interface ActionScript.

2 Spécifiez les propriétés de base de la nouvelle interface dans la boîte de dialogue, puis cliquez sur Terminer.

3 Ajoutez à l’interface ActionScript les éventuelles constantes ou méthodes que les différentes classes partagent.

Création d’un composant ActionScript habillable

Vous pouvez faire appel à un assistant Flash Builder afin de créer rapidement des composants ActionScript pour les projets Flex.

1 Cliquez sur Fichier > Nouveau > Composant ActionScript habillable.

2 Spécifiez les propriétés de base du nouveau composant habillable, puis cliquez sur Terminer.

Flash Builder crée une classe ActionScript étendue depuis le composant de base ou le composant habillable. Par défaut, le composant de base est

spark.components.supportClasses.SkinnableComponent. Vous pouvez

toutefois le modifier sur tout autre composant correspondant à une sous-classe du composant habillable.

Vous pouvez également ajouter toutes les interfaces ActionScript que le nouveau composant habillable peut implémenter. Pour plus d’informations sur la création d’interfaces ActionScript, voir « Création d’une interface

ActionScript » à la page 42.

Le composant

SkinnableComponent est créé dans l’emplacement et le package sélectionné. Par défaut, le logiciel

ajoute automatiquement une référence au composant dans le fichier MXML principal.

Création de fichiers dans un projet

Vous pouvez ajouter des dossiers à un projet selon vos besoins. Par exemple, vous pouvez créer un dossier pour stocker tous vos modèles de données. Vous pouvez également organiser tous les éléments qui constituent l’aspect visuel de votre application.

1 Dans l’Explorateur de packages, sélectionnez Fichier > Nouveau > Dossier.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

2 Si l’espace de travail contient plusieurs projets, sélectionnez le projet à ajouter au dossier autonome.

Si vous créez le dossier dans le dossier du chemin d’accès source, il est considéré comme un nom de package. Vous pouvez ensuite placer les fichiers source reconnus par le compilateur à l’intérieur.

Si vous le créez en dehors du dossier du chemin d’accès source, vous pourrez l’ajouter ultérieurement à ce chemin afin de le transformer en racine d’une structure de packages. Une fois que vous avez terminé cette procédure, sélectionnez Projet > Propriétés, puis Chemin de génération Flex. Cliquez sur Ajouter un dossier et accédez au dossier que vous venez de créer.

3 Entrez le nom du dossier, puis cliquez sur Terminer.

Suppression de dossiers et de fichiers

La suppression de dossiers et de fichiers du projet les élimine de l’espace de travail et, par conséquent, du système de fichiers.

Remarque : la suppression d’une ressource liée ne supprime du projet que le lien, pas la ressource en soi (voir « Liaison à

des ressources situées en dehors de l’espace de travail du projet » à la page 44). Cependant, si vous avez créé un lien à un

dossier et que vous supprimez un ou plusieurs de ses fichiers, ceux-ci sont supprimés du système de fichiers.

1 Dans l’Explorateur de packages, sélectionnez la ressource à supprimer.

2 Sélectionnez Edition > Supprimer ou appuyez sur la touche Suppr, puis cliquez sur Oui.

La ressource est supprimée du système de fichiers.

Recherche de ressources dans le workbench

Flash Builder intègre un outil de recherche qui vous permet de localiser rapidement des ressources.

Pour rechercher le document qui est actuellement ouvert dans l’éditeur, procédez comme suit :

1 Ouvrez le document sur lequel la recherche doit porter.

2 Utilisez l’une des méthodes suivantes :

• Appuyez sur Ctrl+F (Windows) ou Cmd+F (Mac OS).

• Sélectionnez Editer > Rechercher/Remplacer.

3 Saisissez la chaîne de texte à localiser.

4 (Facultatif) Entrez la chaîne de texte de remplacement.

5 (Facultatif) Définissez les critères de recherche avancés.

6 Cliquez sur Rechercher, Remplacer, Remplacer tout ou Remplacer/Rechercher.

Une fois localisée, la chaîne de texte est mise en surbrillance et éventuellement remplacée.

Remarque : pour procéder à une recherche incrémentielle, appuyez sur Ctrl+J (Windows) ou Cmd+J (Mac OS).

Pour rechercher toutes les ressources dans l’espace de travail, Flash Builder comporte des fonctions de recherche avancées plus puissantes que les fonctions de recherche/remplacement. Flash Builder permet de rechercher et de repérer les références ou les déclarations vers les identifiants dans les fichiers ActionScript ou MXML, les projets ou les espaces de travail. Pour plus d’informations, voir « Recherche de références et restructuration du code » à la page 76.

Recherche de fichiers

❖ Sélectionnez Rechercher > Rechercher pour effectuer des recherches de fichiers complexes.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Remarque : cliquez sur Personnaliser pour définir les types d’onglet de recherche disponibles dans la boîte de dialogue Rechercher.

Utilisation de la vue Recherche

La vue Recherche affiche les résultats de votre recherche.

Ouverture d’un fichier de la liste

❖ Double-cliquez sur le fichier.

Suppression d’un fichier de la liste

❖ Sélectionnez le fichier à supprimer, puis cliquez sur Supprimer les occurrences sélectionnées.

Suppression de tous les fichiers de la liste

❖ Cliquez sur Supprimer toutes les occurrences.

Navigation entre les fichiers correspondants

❖ Cliquez sur Afficher l’occurrence suivante ou Afficher l’occurrence précédente.

Affichage des recherches précédentes

❖ Cliquez sur la flèche en regard de l’option Afficher les recherches précédentes et sélectionnez une recherche dans

la liste déroulante.

Retour à la vue Recherche après sa fermeture

1 Sélectionnez Fenêtre > Afficher la vue > Autres.

2 Développez la catégorie Généralités, sélectionnez Recherche, puis cliquez sur OK.

Liaison à des ressources situées en dehors de l’espace de travail du projet

Vous pouvez créer des liens avec des ressources situées en dehors du projet et de l’emplacement de l’espace de travail ainsi qu’avec des dossiers et des fichiers situés n’importe où dans le système de fichiers. Cette option est utile en cas de partage des ressources entre différents projets. Vous pouvez par exemple partager une bibliothèque de composants Flex ou ActionScript personnalisés entre plusieurs projets Flex.

Les dossiers contenant des ressources liées sont signalés dans l’Explorateur de packages (comme l’illustre l’exemple suivant). Vous pouvez ainsi distinguer les ressources normales des ressources liées.

Parmi d’autres exemples de liaison de ressources, citons les dossiers de fichiers d’images ou encore le cas des dossiers de sortie ne se trouvant pas dans le dossier racine du projet.

Lorsque les ressources sont partagées, les modifications que vous apportez aux dossiers et fichiers source affectent tous les projets qui leur sont liés. Soyez prudent lorsque vous supprimez de vos projets des ressources liées. Dans certains cas, vous supprimez simplement la référence au lien ; dans d’autres, vous supprimez la source même. Pour plus d’informations, voir « Suppression de dossiers et de fichiers » à la page 43.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Remarque : il est recommandé de lier d’autres projets aux projets de bibliothèque. Les ressources liées sont encouragées uniquement pour les bibliothèques tierces accompagnées d’un fichier SWC.

Liaison à des ressources situées en dehors de l’espace de travail du projet

1 Dans l’Explorateur de packages, sélectionnez le projet auquel vous souhaitez ajouter des ressources liées.

2 Sélectionnez Fichier > Nouveau > Dossier (ou Fichier).

3 Sélectionnez le projet ou le dossier du projet auquel vous souhaitez ajouter les ressources liées.

4 Saisissez le nom du dossier ou du fichier. Il peut être différent du nom du dossier ou du fichier avec lequel vous

créez un lien.

5 Cliquez sur le bouton Options avancées.

6 Sélectionnez Lier au dossier dans le système de fichiers. Saisissez ou recherchez l’emplacement de la ressource.

7 Cliquez sur Terminer pour lier la ressource au projet.

Utilisation d’une variable de chemin à relier aux ressources

Vous pouvez établir des liens vers des ressources en définissant des variables de chemin. Vous évitez ainsi de devoir saisir le chemin complet d’un dossier local ou d’un dossier réseau dans lequel vous enregistrez les fichiers. Pour plus d’informations, voir « Création d’une variable de chemin » à la page 108.

1 Dans l’Explorateur de packages, sélectionnez le projet auquel vous souhaitez ajouter des ressources liées.

Les variables de chemin peuvent également intervenir dans certains paramètres de projet, tels que le chemin

d’accès à la bibliothèque et le chemin d’accès à la source.

2 Sélectionnez Fichier > Nouveau > Dossier (ou Fichier, si vous voulez ajouter des fichiers).

3 Sélectionnez le projet ou le dossier du projet auquel vous souhaitez ajouter les ressources liées.

4 Cliquez sur le bouton Options avancées.

5 Sélectionnez Lier au dossier dans le système de fichiers. Cliquez sur le bouton Variables.

6 Sélectionnez une variable de chemin définie ou cliquez sur Nouveau pour créer une variable de chemin.

Si vous avez sélectionné une variable de chemin définie, passez à l’étape 9. Si vous avez cliqué sur Nouveau, la boîte de dialogue Nouvelle variable s’affiche.

7 Saisissez le nom de la variable de chemin et saisissez ou recherchez l’emplacement du fichier ou du dossier.

Cliquez sur OK pour créer la variable de chemin.

8 Sélectionnez la nouvelle variable de chemin dans la boîte de dialogue Sélection d’une variable de chemin, puis

cliquez sur OK.

9 Cliquez sur Terminer pour terminer la création du lien vers la ressource.

Vous pouvez également définir et gérer des variables de chemin dans les préférences du workbench de Flash Builder (dans la boîte de dialogue Préférences, sélectionnez Général > Espace de travail > Ressources liées).

Déplacement de ressources entre les projets d’un espace de travail

Lorsque vous travaillez avec plusieurs projets dans un espace de travail, vous pouvez déplacer des ressources d’un projet vers un autre.

1 Dans l’Explorateur de packages, sélectionnez la ressource à déplacer.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

2 Effectuez l’une des opérations suivantes :

• Faites glisser la ressource vers un nouveau projet.

• Coupez et collez la ressource dans un autre projet.

Remarque : vous pouvez déplacer des ressources normales et des ressources liées. Pour plus d’informations sur la liaison de ressources, voir « Liaison à des ressources situées en dehors de l’espace de travail du projet » à la page 44.

Partage de ressources entre les projets

Pour partager des ressources entre plusieurs projets, placez-les dans des dossiers qui pourront ensuite être reliés aux différents projets à l’aide du chemin d’accès source de ces derniers. Il s’agit de la meilleure méthode de partage de ressources, telles que les classes, les composants MXML et les images. Les mises à jour de ces ressources sont immédiatement disponibles pour tous les projets qui les utilisent. Lorsque les projets sont compilés, les ressources partagées sont ajoutées au fichier SWC.

Ajout d’un dossier de ressources externes au chemin d’accès source

1 Sélectionnez un projet dans l’Explorateur de packages.

2 Sélectionnez Projet > Propriétés > Chemin de génération Flex (ou Chemin de génération ActionScript si vous

utilisez un projet ActionScript).

3 Sur la page des propriétés du chemin de génération, cliquez sur l’onglet Chemin source.

4 Cliquez sur le bouton Ajouter un dossier.

5 Saisissez ou recherchez le chemin du dossier, puis cliquez sur OK.

Le dossier est ajouté au chemin source.

L’onglet de propriétés Chemin source vous permet également de modifier, supprimer ou changer l’ordre des éléments du chemin source.

Les dossiers qui sont ajoutés au chemin source sont signalés dans l’Explorateur de packages.

Actualisation des ressources dans l’espace de travail

A mesure que vous modifiez, ajoutez ou supprimez les ressources d’un projet, le workbench actualise automatiquement les différentes vues qui affichent ces ressources. La suppression d’un fichier du projet par exemple est immédiatement répercutée dans l’Explorateur de packages.

Vous pouvez également modifier des ressources situées en dehors de Flash Builder, directement dans le système de fichiers. Ces modifications ne sont visibles dans Flash Builder qu’après actualisation de l’espace de travail.

Par défaut, l’espace de travail de la configuration autonome de Flash Builder est actualisé automatiquement. Cette option peut être modifiée dans les préférences de Flash Builder. Ouvrez la boîte de dialogue Préférences et sélectionnez Général > Espace de travail. Vous pouvez également modifier le comportement par défaut de Flash Builder et désactiver l’actualisation automatique de l’espace de travail.

Actualisation manuelle de l’espace de travail

❖ Dans le menu contextuel de l’Explorateur de packages, sélectionnez Actualiser. Toutes les ressources de projet dans

l’espace de travail sont actualisées.

Désactivation de l’actualisation automatique

1 Ouvrez la boîte de dialogue Préférences et sélectionnez Général > Espace de travail.

2 Désélectionnez l’option Actualiser automatiquement.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Initiation à Flash Builder

Alternatives à l’utilisation de références de projets

Les références de projet pouvant avoir une incidence sur l’ordre de génération, Flash Builder propose une alternative à leur utilisation.

Projets de bibliothèque Flex Méthode priviliégiée de création d’une bibliothèque réutilisable. Flash Builder crée une

référence de projet pour garantir que le projet SWC est généré avant le projet principal qui le contient sur le chemin d’accès à la bibliothèque. En outre, puisque Flash Builder l’ajoute au chemin de la bibliothèque, des conseils de code apparaissent dans le projet principal pour les classes du projet SWC.

Chemin source Méthode recommandée pour inclure du code dans le projet ne se trouvant pas sous la même structure

de dossier. Elle active les conseils de code dans les fichiers du projet et dans les classes situées dans des fichiers liés. Le compilateur sait où trouver le code source. Vous pouvez ajouter au projet un nombre quelconque de chemins source. Ils s’affichent en tant que dossiers liés dans l’Explorateur de packages.

Dernière mise à jour le 8/7/2011

Chapitre 3 : Outils de développement de code dans Flash Builder

Dans Adobe® Flash® Builder™, la modification des codes MXML, ActionScript et CSS advient dans des éditeurs différents. Le workbench de Flash Builder intègre à la fois les projets et les documents, permettant ainsi l’ouverture automatique de l’éditeur correspondant au type de ressource. Les éditeurs de Flash Builder partagent les mêmes fonctionnalités, parmi lesquelles les conseils de code, la navigation, le formatage, la restructuration ainsi que d’autres fonctions d’amélioration de la productivité.

Assistant de contenu

En cours de rédaction de code MXML, ActionScript et CSS, des conseils et des documents de référence ASDoc s’affichent afin de faciliter la saisie. Cette fonction porte le nom d’assistant de contenu.

Dans l’éditeur MXML, la saisie dans le cadre d’un composant MXML conduit par exemple à l’affichage d’une liste contenant toutes les propriétés de ce composant. L’exemple suivant illustre les conseils de code pour les propriétés d’un composant MXML.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

La sélection et la saisie d’une propriété entraînent l’affichage des valeurs possibles (à condition que des valeurs prédéfinies existent). L’exemple suivant illustre les conseils de code pour les valeurs de propriété.

Le fonctionnement de l’assistant de contenu dans les éditeurs ActionScript et CSS est analogue.

Assistant de contenu dans l’éditeur MXML

Dans l’éditeur MXML, les conseils de code s’affichent automatiquement à la saisie du code. L’exemple suivant illustre les conseils de code qui s’affichent lorsque vous ajoutez une balise à une balise Panel, ainsi que la documentation de référence ASDoc. Cliquez à l’intérieur du contenu ASDoc ou appuyez sur la touche F2 pour afficher le contenu dans une fenêtre distincte que vous pouvez faire défiler. Cliquez en dehors de la fenêtre ASDoc pour la fermer.

L’assistant de contenu classe les conseils de code par type, répertoriant les composants MXML visuels et non visuels, par propriétés, par événements et par styles.

Par défaut, l’assistant de contenu affiche uniquement les indicateurs correspondant aux types recommandés. Les types recommandés sont les composants disponibles dans les espaces de noms ou autres, suivant les balises englobantes. Les composants dont vous disposez dépendent de la déclaration d’espace de noms de l’application concernée ainsi que des balises englobant le point d’insertion dans l’éditeur.

Dans certains contextes par exemple, seuls les composants Spark sont autorisés. D’autres contextes autorisent les composants Spark et les composants Halo. L’assistant de contenu filtre les conseils de code en fonction du contenu.

Appuyez à plusieurs reprises sur les touches Ctrl+Espace pour faire défiler les filtres pour les conseils de code affichés. Les filtres sont les suivants :

• Affichage initial : Types recommandés

• Tous les composants

• Propriétés

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

• Evénements

• Effets

• Styles

• Retour aux types recommandés

Les conseils de code affichés et l’ordre dans lequel ils défilent dépendent des préférences définies par l’utilisateur. Pour modifier le paramètre par défaut dans la boîte de dialogue Préférences, voir « Code MXML » à la page 265.

Assistant de contenu dans l’éditeur ActionScript

Les conseils de code apparaissent automatiquement lorsque vous saisissez du code ActionScript dans l’éditeur ActionScript.

L’assistant de contenu filtre les conseils de code en fonction du contenu. Appuyez à plusieurs reprises sur les touches Ctrl+Espace pour faire défiler les filtres pour les conseils de code affichés. Les filtres sont les suivants :

• Modèles

• Variables

• Fonctions

• Classes et interfaces

• Packages

• Espaces de noms

Assistant de contenu dans l’éditeur CSS

L’assistant de contenu affiche des indicateurs pour les styles CSS contenus dans des balises intégrées <fx:Style> ou dans des documents CSS autonomes, ainsi que l’illustre l’exemple suivant.

Remarque : dans les documents CSS, les conseils de code s’affichent uniquement si vous appuyez sur Ctrl+Espace.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

L’assistant de contenu propose également des indicateurs pour les classes de composants contenues dans la balise ClassReference d’un document CSS, ainsi que l’illustre l’exemple suivant :

Vous pouvez également saisir les noms complets des classes. Dans ce cas, les classes et packages disponibles s’affichent comme suit :

La balise ClassReference fournit une navigation par hyperliens qui vous permet d’accéder au composant référencé ou à la classe d’habillage. Pour ce faire, appuyez sur la touche Ctrl (touche Commande sur Mac) et déplacez le curseur sur la balise. Le nom de la classe se transforme en hyperlien. Pour plus d’informations sur la navigation par hyperliens, voir « Ouverture des définitions de code » à la page 81.

Affichage du résumé du guide de référence ActionScript

1 Commencez à entrer une ligne de code qui contient une classe MXML ou ActionScript. Vous pouvez également

survoler la classe avec le curseur de la souris.

Au fur et à mesure que vous tapez, le résumé du guide de référence ActionScript correspondant à la classe apparaît à côté des conseils de code. Si vous survolez une classe avec le curseur de la souris, seul le résumé du guide de référence ActionScript s’affiche.

2 Cliquez à l’intérieur du résumé du guide de référence ActionScript ou appuyez sur la touche F2 pour afficher le

contenu du guide de référence ActionScript dans une fenêtre distincte que vous pouvez faire défiler. Lorsque vous avez terminé la lecture de la documentation, cliquez hors de la fenêtre. La fenêtre ASDoc se ferme.

3 Pour afficher la vue ASDoc, appuyez sur Ctrl+3, puis saisissez asdoc et sélectionnez Vues.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Assistant rapide

La fonctionnalité Assistant rapide d’Adobe Flash Builder fournit une assistance contextuelle qui permet de réaliser rapidement une tâche. L’Assistant rapide vous permet de sélectionner une action dans une liste d’actions applicables à votre fragment de code actuel.

Pour appeler l’Assistant rapide, sélectionnez Assistant rapide dans le menu contextuel de l’éditeur, puis choisissez l’action requise. Vous pouvez également utiliser le raccourci clavier Ctrl+1+ O (Windows) ou Commande+1+O (Mac).

Les options suivantes de l’Assistant rapide sont actuellement disponibles :

Renommer dans le fichier

Utilisez l’Assistant rapide pour renommer les éléments de code pour lesquels l’action Renommer/Restructurer est activée. Il peut s’agir de noms de variables, méthodes, classes, de paramètres, d’importations, d’états et du code ActionScript à l’intérieur des balises MXML.

Pour renommer toutes les occurrences d’une variable ou méthode dans votre fichier, placez le curseur sur le nom de la variable ou méthode sélectionnée, puis appuyez sur Ctrl+1. Sélectionnez ensuite l’option Renommer dans le fichier pour renommer la variable ou la méthode. De même, vous pouvez modifier la propriété d’ID d’un composant MXML.

Renommer dans l’espace de travail

Utilisez l’Assistant rapide pour renommer les éléments de code pour lesquels l’action Renommer/Restructure est activée dans tous les fichiers de votre espace de travail.

Pour renommer toutes les occurrences d’une variable ou méthode dans votre espace de travail, placez le curseur sur le nom de la variable ou méthode sélectionnée, puis appuyez sur Ctrl+1. Sélectionnez ensuite l’option Renommer dans l’espace de travail pour renommer la variable ou la méthode. Vous pouvez actualiser toutes les références à la variable ou méthode dans votre espace de travail.

Organiser les importations

Placez le curseur sur n’importe quelle instruction d’importation, puis appuyez sur Ctrl+1. Sélectionnez ensuite l’option d’organisation des importations. Pour plus d’informations sur l’organisation des instructions d’importation, voir « Organisation des instructions d’importation » à la page 86.

Générer l’instruction d’importation

Si vous avez une variable non définie, vous pouvez placer votre curseur à n’importe quel endroit sur la ligne de code, puis appuyez sur Ctrl + 1. Une option permettant d’importer le composant s’affiche. Si le composant possède des équivalents MX et Spark, les deux options apparaissent.

Par exemple, si votre code comporte la variable non définie

var btn:Button;

btn, comme suit :

Placez votre curseur à n’importe quel endroit sur la ligne de code, puis appuyez sur Ctrl +1. Les options d’importation du composant Button s’affichent. Si vous sélectionnez le composant Spark Button, l’instruction d’importation est créée comme suit :

import spark.components.Button;

Fractionner la déclaration de variable

Utilisez l’Assistant rapide pour fractionner une variable en deux parties : la déclaration de la variable et l’initialisation de la variable.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

L’Assistant rapide apparaît dans les contextes suivants.

Contexte Exemple

Variables locales dans une fonction Si vous possédez une fonction, comme suit :

public function TestAS() { var i:int=10; }

Pour fractionner la variable à l’aide de l’Assistant rapide, placez votre curseur à n’importe quel endroit dans la déclaration de la variable

i:int=10;

permettant de fractionner la déclaration de la variable.

La variable est fractionnée comme suit :

public function TestAS() {

var i:int; i=10;

}

Plusieurs variables dans une fonction Si vous possédez une fonction de ce type :

public function TestAS() { var i:int=10, j:int=20; }

Pour fractionner les variables à l’aide de l’Assistant rapide, placez votre curseur à n’importe quel endroit dans la déclaration de la variable

i:int=10, j:int=20;

l’option permettant de fractionner la déclaration de la variable.

Vous pouvez fractionner la variable comme suit :

public function TestAS() {

var i:int, j:int=20; i=10;

}

Vous pouvez encore fractionner la variable j:int=20; en plaçant votre curseur à n’importe quel endroit au sein de la déclaration de la variable, puis en appuyant sur Ctrl+1. Ensuite, sélectionnez l’option permettant de fractionner la déclaration de la variable.

La variable est fractionnée comme suit :

public function TestAS() {

var i:int, j:int; j=20; i=10;

}

et appuyez sur Ctrl+1. Ensuite, sélectionnez l’option

et appuyez sur Ctrl+1. Ensuite, sélectionnez

var

Attribution à une variable

Lorsque vous évaluez une expression ActionScript, si l’expression renvoie une valeur, vous pouvez appeler l’Assistant rapide pour créer une variable pour cette expression. L’Assistant rapide n’est pas disponible pour les méthodes ne possédant pas de type de retour ou si le type de retour est

void.

Le nom de la variable qui est créée découle du nom de la fonction ou de l’identifiant dans l’expression. Si le nom dérivé existe, il est incrémenté.

Par exemple, si vous avez le code suivant :

var i:int; i;

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Placez votre curseur après "i", puis appuyez sur Ctrl+1. Sélectionnez ensuite Attribuer l’instruction à une nouvelle variable locale. Une variable incrémenté à

var i:int; var i2:int = i;

"i2" comme suit :

"i2" est créée. Comme la variable i est déjà présente, le nom de la nouvelle variable est

Par exemple, l’attribution à une variable apparaît dans les contextes suivants :

Contexte Exemple

Expression littérale L’Assistant rapide prend en charge une vaste gamme d’expressions simples

Appel de méthode Si vous avez le code suivant dans une méthode :

Accès à la propriété Si vous avez le code suivant dans une propriété :

et complexes.

Par exemple, si vous avez l’expression suivante :

100+150

Placez votre curseur à n’importe quel endroit dans l’expression, puis appuyez sur Ctrl+1 pour obtenir un code ressemblant à celui-ci :

var number2:Number = 110 + 500;

var ac:ArrayCollection = new ArrayCollection(); ac.createCursor();

Placez votre curseur dans ac.createCursor();, puis appuyez sur Ctrl+1. Sélectionnez ensuite l’option Attribuer l’instruction à une nouvelle variable locale. La variable locale est créée comme suit :

var createCursor:IViewCursor = ac.createCursor();

var ac:ArrayCollection = new ArrayCollection(); ac.source;

Placez votre curseur à n’importe quel endroit dans ac.source, puis appuyez sur Ctrl+1. Sélectionnez ensuite l’option Attribuer l’instruction à une nouvelle variable locale. La variable locale est créée comme suit :

var source:Array = ac.source;

Conversion de la variable locale en champ

Lorsque vous disposez de variables locales dans une fonction, l’Assistant rapide vous permet de créer un champ dans la classe.

Par exemple, si vous avez une variable dans une fonction, comme suit :

var i:int = 10;

Placez votre curseur à n’importe quel endroit dans la définition de la variable, puis appuyez sur Ctrl+1. Sélectionnez ensuite Convertir la variable locale en champ. Le champ de la classe est créé comme suit :

private var i:int;

Le nom du nouveau champ est le même que celui de la variable locale, à condition qu’il n’existe aucun conflit dans la portée de la classe. Si le nom existe, le nom du champ est incrémenté et vous pouvez renommer la variable ou la méthode dans votre fichier.

Génération des méthodes Get/Set

L’Assistant rapide vous permet de générer des méthodes Get/Set (fonctions d’accesseur Get et Set) pour les variables de classes.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Par exemple, si votre code ressemble au suivant :

private var result:ResultEvent;

Placez votre curseur dans la variable result, puis appuyez sur Ctrl+1. Sélectionnez ensuite l’option Assistant rapide pour créer les méthodes Get/Set destinée au résultat. La boîte de dialogue Générer les méthodes Get/Set apparaît. Cette boîte de dialogue vous permet de spécifier une nouvelle fonction Get/Set. Pour plus d’informations sur la génération de méthodes Get/Set, reportez-vous à la section « Génération de fonctions d’accesseur Get ou Set » à la page 73.

Génération de fonctions

L’Assistant rapide vous permet de générer des fonctions spéciales, telles que labelFunction, iconFunction, etc.

Par exemple, pour créer une fonction labelFunction pour le code suivant :

<mx:DataGrid labelFunction="lblfunc" dataTipFunction="tipFunc" />

Placez votre curseur dans "lblfunc", puis appuyez sur Ctrl+1. Sélectionnez ensuite l’option de l’Assistant rapide permettant de créer la fonction labelFunction. Le code de remplacement de la fonction est généré comme suit :

protected function lblfunc(item:Object, column:DataGridColumn):String

{ // TODO Auto-generated method stub }

Génération de gestionnaires d’événements à partir du code MXML

L’Assistant rapide vous permet de générer des gestionnaires d’événements avec des noms de gestionnaires personnalisés au sein du code MXML.

Par exemple, pour générer un gestionnaire d’événement en cliquant sur la balise <mx:Button>, entrez le code suivant :

<mx:Button click="clickHandler" />

Placez ensuite votre curseur dans "clickHandler", appuyez sur Ctrl+1, puis sélectionnez Générer un gestionnaire d’événement. Le gestionnaire d’événement et le code de remplacement sont générés comme suit :

<mx:Button click="clickHandler(event)" />

protected function clickHandler(event:MouseEvent):void

{

// TODO Auto-generated method stub

}

Vous pouvez également générer un gestionnaire d’événements pour le code suivant, en appuyant sur Ctrl+1 n’importe où dans

<mx:Button click="clickHandler(event)" />

"clickHandler(event)".

Pour personnaliser le code de remplacement généré par Flash Builder, voir « Modèles de code » à la page 56.

Remplacement ou implémentation de méthodes

Flash Builder permet de sélectionner et de remplacer des méthodes d’une classe parent ou d’implémenter des méthodes d’interface.

1 Ouvrez la boîte de dialogue Remplacer/Implémenter des méthodes en sélectionnant l’option correspondante dans

le menu Source. Vous pouvez également sélectionner Source > Remplacer/Implémenter des méthodes dans le menu contextuel de l’éditeur MXML ou ActionScript.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

2 Les méthodes de chaque classe parent s’affichent sous forme d’arborescence. Pour chaque classe, vous pouvez

sélectionner les méthodes à remplacer et les méthodes à implémenter.

3 Vous pouvez choisir le point d’insertion pour insérer les méthodes sélectionnées. L’option de point d’insertion par

défaut dépend de l’emplacement du curseur dans l’éditeur lors de l’ouverture de la boîte de dialogue Remplacer/Implémenter des méthodes. La variable ou la méthode la plus proche de l’emplacement du curseur apparaît comme option de point d’insertion.

Flash Builder génère le code de remplacement pour les méthodes sélectionnées.

Pour personnaliser le code de remplacement prédéfini généré par Flash Builder, voir « Modèles de code » à la page 56.

Modèles de code

Les modèles de code permettent d’accélérer l’activité de codage grâce à l’insertion automatique de motifs de codage employés fréquemment.

Flash Builder inclut différents modèles de code prédéfinis. Vous pouvez également définir des modèles de code supplémentaires pour les motifs de code couramment utilisés. Pour voir tous les modèles de code disponibles, ouvrez la boîte de dialogue Préférences et sélectionnez Flash Builder > Editeurs > Modèles de code.

Paul Robertson, professionnel de la communauté Adobe, a publié sur son blog un article sur l’utilisation de

modèles de code.

Modèles de code MXML, ActionScript et CSS

Les modèles de code ActionScript, CSS et MXML sont basés sur le contexte et peuvent être appelés en appuyant sur Ctrl + Espace. Vous pouvez utiliser les modèles prédéfinis fournis avec Flash Builder ou créer vos propres modèles.

Insertion des modèles de code.

Pour insérer un modèle de code dans l’éditeur de code, saisissez le nom du modèle dans l’éditeur de code et appuyez sur Ctrl+Espace.

Par exemple, lors de l’écriture de code ActionScript, supposons que vous utilisez à plusieurs reprises la boucle Vous pouvez dans ce cas définir un modèle de code pour la boucle

for (var i:int = 0; i < array.length; i++) { }

for de la manière suivante :

Lorsque vous utilisez un modèle de code, il n’est pas nécessaire de saisir le code complet pour la boucle for. A la place, dans la classe ActionScript, tapez ’

for s’affiche. Lorsque vous sélectionnez le modèle de code, le code défini dans le modèle est inséré.

boucle

for’ et appuyez sur Ctrl+Espace. Une option de modèle permettant de créer la

Les modèles peuvent également contenir des variables de modèle. Les variables de modèle sont définies entre les symboles

Par exemple, si vous définissez un modèle de code pour la boucle

for (var ${index}:int = 0; ${index} < ${array}.length; ${index}++) { ${cursor} }

${}. Elles sont résolues en fonction de la définition de variable correspondante dans l’éditeur.

for de la manière suivante :

for.

Puis, si vous appelez le modèle de code après avoir défini une variable myArr de la manière suivante :

{

var myArr:ArrayCollection = null;

}

Dans ce cas, ${array} dans le modèle de code est résolu comme myArr et le code résultant présente l’aspect suivant :

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

{

var myArr:ArrayCollection = null; for (var ${index}:int = 0; ${index} < myArr.length; ${index}++) { ${cursor} }

}

Création et modification de modèles de code

1 Ouvrez la boîte de dialogue Préférences et sélectionnez Flash Builder > Editeurs > Modèles de code.

2 Les modèles de code sont classés dans les catégories ActionScript, MXML et CSS. Chaque catégorie contient un

ensemble de modèles de code prédéfinis. Vous pouvez modifier un modèle existant ou en ajouter un nouveau.

3 Pour ajouter un nouveau modèle, sélectionnez la catégorie du modèle de code et cliquez sur Ajouter. Dans la boîte

de dialogue Nouveau modèle, saisissez un nom et une description succincte pour le modèle de code. Spécifiez ensuite un contexte dans lequel le modèle de code doit être appelé.

Vous pouvez spécifier des contextes pour les modèles de code ActionScript et MXML.

Vous disposez des contextes ActionScript suivants :

• ActionScript : insère le modèle de code à un endroit quelconque du document ActionScript.

• ActionScript statement : insère le modèle de code dans les fonctions et dans les éléments d’une classe.

• ActionScript members : insère le modèle de code uniquement dans les éléments d’une classe.

• ActionScript Package Scope : insère le modèle de code dans un package, de la manière suivante :

Package

{ /* insert code template*/ }

Vous disposez des contextes MXML suivants :

• MXML : insère le modèle de code à un endroit quelconque du document MXML.

• MX Component : insère le modèle de code dans les composants MX disponibles pour le SDK Flex 3.

• Spark Components : insère le modèle de code dans les composants Spark disponibles pour le SDK Flex 4.

• MXML attributes : insère le modèle de code pour les attributs MXML dans les composants MX et Spark.

4 Saisissez le code correspondant au modèle dans la section Motif. Pour insérer des variables dans le code, cliquez sur

Insérer une variable et sélectionnez une variable prédéfinie dans la liste. Les variables sont liées à la catégorie du modèle.

Les modèles ActionScript contiennent des variables prédéfinies, notamment

enclosing_package, enclosing_type, field, local_var et var. Les modèles MXML contiennent des variables

prédéfinies, notamment

5 Si vous ne souhaitez pas que Flash Builder insère automatiquement le modèle de code dans votre code, désactivez

fx, mx, s et tag.

array, enclosing_method,

l’option Insertion automatique dans le code.

6 Pour personnaliser un modèle de code existant, sélectionnez le modèle et cliquez sur Modifier. Après avoir modifié

le modèle, cliquez sur OK.

Pour plus d’informations sur la personnalisation des modèles de fichier et des variables de modèle, voir « Personnalisation des modèles de fichier » à la page 62 et « Variables des modèles » à la page 65.

Vous pouvez à tout moment supprimer le modèle personnalisé et rétablir le modèle de code prédéfini en cliquant sur Rétablir la valeur par défaut.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Par défaut, vous pouvez appeler tous les modèles prédéfinis à l’aide de l’assistant de contenu. Si toutefois vous souhaitez exclure un modèle spécifique des options de l’assistant de contenu, désactivez ce modèle dans la section Modèles existants.

Vous pouvez également importer et exporter des modèles de code. Vous pouvez sélectionner un ou plusieurs modèles et les exporter. Les modèles sont exportés sous forme de fichier XML.

Paul Robertson, professionnel de la communauté Adobe, a publié sur son blog un article sur le partage de modèles

de code.

Modèles de code Flash Builder

Flash Builder peut générer automatiquement un code prédéfini dans les scénarios suivants :

• « Génération de gestionnaires d’événement » à la page 213

• « Génération de fonctions d’accesseur Get ou Set » à la page 73

• « Génération à partir de l’utilisation » à la page 71 (code d’élément de remplacement de l’emplacement réservé pour

une méthode non définie)

• « Remplacement ou implémentation de méthodes » à la page 55

Vous pouvez personnaliser le modèle de code prédéfini généré par Flash Builder.

Personnalisation du modèle de code

1 Ouvrez la boîte de dialogue Préférences, puis sélectionnez Flash Builder > Editeurs > Modèles de code > Flash

Builder.

2 Sélectionnez le nom du modèle de code que vous souhaitez personnaliser, puis cliquez sur Editer. Par exemple, pour

personnaliser le code généré lorsque vous générez un gestionnaire d’événement, sélectionnez le modèle de gestionnaire d’événement, puis cliquez sur Editer.

3 Vous pouvez personnaliser le nom du modèle, la description et le motif de code.

4 Pour insérer une variable dans le code, cliquez sur Insérer une variable, puis sélectionnez la variable. Pour plus

d’informations à propos des variables de code disponibles, voir « Utilisation de variables de code » à la page 59.

5 Vous pouvez à tout moment annuler les modifications en cliquant sur Rétablir la valeur par défaut.

6 Vous pouvez aussi importer et exporter le modèle de code. Vous pouvez sélectionner un ou plusieurs modèles et

les exporter. Les modèles sont exportés sous forme de fichier XML.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Utilisation de variables de code

Variables de code pour les gestionnaires d’événement

Variable Description Exemple

${ID_composant} Se résout à l’ID unique du composant. Si l’ID du composant du bouton est

${nom_composant} Se résout au nom de la balise.

${nom_événement} Indique le nom de l’événement. clickEvent, onHover

${type_événement} Se résout au type de gestionnaire d’événement. Flash Builder désigne un type d’événement

gestionnaire d’événement généré est

test_clickHandler.

Si vous n’avez pas spécifié de valeurs d’ID, les valeurs générées automatiquement sont composant1, composant2, etc.

${namespace} ${modifiers}function ${:method_name('${component_id} _${event_name}Handler')}(${even t}:${event_type}):${return_type } { // TODO Auto-generated method stub ${cursor} }

par défaut pour chaque composant de l’interface utilisateur.

Lors de la génération d’un événement de clic pour un composant de bouton, un gestionnaire d’événement de type MouseEvent est généré comme suit :

button1_clickHandler(event:Mous eEvent)

test, le

${modificateurs} Indique les modificateurs de la fonction

générée.

${nom_méthode} Se résout au nom du gestionnaire

d’événement.

${espace de noms} Définit la valeur d’espace de noms pour la

fonction générée.

static

Pour un événement de clic du composant Bouton, le nom du gestionnaire d’événement peut être button1_clickHandler

La valeur d’espace de noms peut être l’une des suivantes :

• protected

• public

• private

La valeur par défaut est protected.

Exemple d’utilisations de variables de code pour les fonctions du gestionnaire d’événement :

${namespace} ${modifiers}function ${:method_name('${component_id}_${event_name}Handler')} ${event}:${event_type}):${return_type}

{

// TODO Auto-generated method stub ${cursor} }

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Variables de code pour les fonctions d’accesseur get and set

Variable Description Exemple

${métadonnées} Spécifie les balises de métadonnées qui sont

générées

${asdoc} Spécifie les ASDoc qui sont générés pour les

fonctions d’accesseur get and set

${type_retour} Se résout au type de variable.

Si le type de variable n’est pas spécifié, la fonction d’accesseur get générée n’a pas de type de retour.

${propriété}} Se résout au nom de la propriété dans la boîte

de dialogue des méthodes get/set.

${type_argument} Se résout au type de données de la fonction set

générée.

Génération de fonctions d’accesseur get and set pour une variable Bindable

${metadata} ${asdoc}${namespace} ${modifiers}function get ${method_name}()${return_type} { return ${property}; }

Pour une variable var i:int, i se résout à

Exemple d’utilisation de variables de code pour les fonctions d’accesseur get et set :

${asdoc} ${namespace} ${modifiers}function set ${method_name}(value${argument_type}):void {

if( ${property} !== value)

{

${property} = value; dispatchEvent(new Event("${event_name}"));

}

Variables de code pour les fonctions dans une classe indéfinie

Variable Description Exemple

${params} Pour une fonction indéfinie qui accepte un

nombre spécifié d’arguments, la fonction générée possède le même nombre d’arguments de ce type.

Remplissage du code de métadonnées

Flash Builder affiche des indicateurs de remplissage du code des métadonnées que vous utilisez dans vos documents MXML et ActionScript.

Dans un document MXML, les indicateurs de remplissage du code s’affichent dans les balises

<fx:Script> intégrées. Dans un document ActionScript, les indicateurs de remplissage du code s’affichent également

pour les éléments de langage ActionScript, tels que les noms de classe, les variables et les méthodes Set/Get.

Dernière mise à jour le 8/7/2011

<fx:Metadata> et

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Les conseils de code sont liés au contexte du document MXML et Action Script, ainsi qu’au code dans lequel les métadonnées sont utilisées. Par exemple, lorsque vous appelez l’assistant de contenu au sein de deux lignes vierges d’une instruction ActionScript, les conseils de code applicables uniquement à cette instruction ActionScript apparaissent. Pour voir tous les conseils de code valides applicables au document ActionScript ou MXML, appuyez plusieurs fois sur Ctrl+Espace pour parcourir les conseils de code disponibles.

Utilisation du remplissage du code de métadonnées dans les documents MXML

Dans un document ou une classe MXML, vous pouvez utiliser le remplissage du code de métadonnées comme suit :

• Saisissez les balises « [ » dans <fx:Metadata> comme suit :

<fx:Metadata>

[

</fx:Metadata>

• Saisissez les balises « [ » dans <fx:Script> comme suit :

<fx:Script>

<![CDATA[

[

]]>

</fx:Script>

Utilisation du remplissage du code de métadonnées dans les documents ActionScript

Dans un document ActionScript, vous pouvez utiliser le remplissage du code de métadonnées lorsque vous saisissez ’[’ avant un nom de classe, une variable, une méthode get ou une méthode set, comme suit :

[

class GetSet {

[

private var privateProperty:String; [ public function get publicAccess():String {

return privateProperty; } [ public function set publicAccess(setValue:String):void {

privateProperty = setValue; }

}

Remplissage du code pour les balises de métadonnées personnalisées

Flash Builder prend en charge le remplissage du code pour les balises de métadonnées personnalisées qui sont introduites lors de l’utilisation de structures Flex tierces.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Pour activer les conseils de code pour les balises de métadonnées personnalisées dans votre projet, générez un fichier SWC contenant un fichier

1 Créez un projet de bibliothèque. L’assistant de création d’un projet de bibliothèque Flex vous guide à travers les

metadata.xml, comme suit :

différentes étapes et vous demande d’indiquer le nom du projet, son emplacement, ainsi que le chemin de génération. Pour plus d’informations, voir « Création de projets de bibliothèque Flex » à la page 228.

2 Ajoutez le fichier metadata.xml dans le dossier src, sous le dossier racine de votre projet de bibliothèque. Incluez

toutes les balises de métadonnées que vous souhaitez dans le fichier

Ajoutez le fichier

metadata.properties (le cas échéant) dans le dossier de paramètres régionaux approprié. Par

metadata.xml.

exemple : locale/en_US ou locale/fr_FR.

Pour plus d’informations sur les balises de métadonnées, voir About metadata tags dans la documentation Flex.

3 Incluez le fichier metadata.xml dans le fichier SWC de bibliothèque, comme suit :

a Sélectionnez Projet > Propriétés > Chemin de génération de bibliothèque Flex.

Le fichier

b Sélectionnez le fichier metadata.xml à inclure dans le fichier SWC, puis cliquez sur OK.

metadata.xml que vous avez ajouté apparaît sous l’onglet Ressources.

Le fichier SWC est compilé et généré dans le dossier de sortie (bin) du projet de bibliothèque.

4 Sélectionnez le dossier de paramètres régionaux auquel vous avez ajouté le fichier metadata.properties (le cas

échéant).

5 Une fois le fichier SWC généré, ajoutez-le au chemin de génération de votre projet, comme suit :

1 Sélectionnez Projet > Propriétés > Chemin de génération Flex.

2 Cliquez sur Ajouter un fichier SWC.

3 Accédez à l’emplacement du fichier SWC ou saisissez-le, puis cliquez sur OK.

Une fois le fichier SWC ajouté à votre chemin de génération, les indicateurs de remplissage du code de métadonnées apparaissent pour les balises de métadonnées définies dans le fichier

metadata.xml. Vous pouvez partager le fichier

SWC entre vos applications ou les distribuer à d’autres développeurs.

Personnalisation des modèles de fichier

Flash Builder vous permet de personnaliser les informations par défaut contenues dans les nouveaux fichiers MXML, ActionScript et CSS. Il peut s’agir par exemple des variables définissant l’auteur et la date, des variables pour les balises et les attributs d’ouverture et de fermeture ainsi que des variables pour différentes déclarations ActionScript, pour différents préfixes d’espace de noms et pour presque tout contenu que vous souhaitez inclure dans un modèle de fichier. Les modèles de fichier sont utiles notamment pour spécifier des commentaires d’introduction et des informations de copyright.

Le contenu d’un nouveau fichier est spécifié dans un modèle de fichier accessible à partir de Préférences > Flash Builder > Modèles de fichier. Des modèles sont disponibles pour les types de fichier suivants.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

ActionScript Fichier ActionScript

Classe ActionScript

Interface ActionScript

Composant habillable ActionScript

MXML Application Web MXML

Application de bureau MXML

Composant MXML

Module MXML

Habillage MXML

Rendu d’élément pour composants Spark

Rendu d’élément pour composants MX

Rendu d’élément pour composant MX DataGrid

Rendu d’élément pour composant AdvancedDataGrid

Rendu d’élément pour composant MX Tree

FlexUnit Classe TestCase FlexUnit

Classe TestSuite FlexUnit

Classe TestCase FlexUnit4

Classe TestSuite FlexUnit4

CSS Fichier CSS

Une fois modifié, un modèle peut être exporté afin de pouvoir être partagé avec les autres membres de votre équipe.

Modification d’un modèle de fichier

1 Sélectionnez Préférences > Flash Builder > Modèles de fichier.

2 Développez les types de fichier et sélectionnez le modèle que vous souhaitez modifier.

3 Cliquez sur Editer et modifiez le modèle.

Vous pouvez saisir les données directement dans l’éditeur Modèle ou sélectionner Variables afin d’insérer des données prédéfinies dans le modèle.

4 Cliquez sur OK pour enregistrer les modifications.

Les modifications sont appliquées aux nouveaux fichiers.

Exportation et importation de modèles de fichier

1 Sélectionnez Préférences > Flash Builder > Modèles de fichier.

2 Développez les types de fichier et sélectionnez un modèle.

3 Cliquez sur Exporter pour exporter le modèle vers un système de fichiers ou Importer pour importer un modèle

précédemment exporté.

Les modèles sont exportés dans des fichiers XML.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Restauration des valeurs par défaut

Remarque : le bouton Restaurer les valeurs par défaut rétablit les valeurs par défaut de tous les modèles de fichier. Vous ne pouvez pas restaurer les valeurs par défaut d’un seul modèle.

❖ Pour restaurer les modèles par défaut, ouvrez la fenêtre Préférences > Flash Builder > Modèles de fichier et

sélectionnez Restaurer les valeurs par défaut.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Variables des modèles

Variables des modèles pour tous les types de fichiers

Variable Description Exemple

${date} Date actuelle 15 février 2009

${year} Année actuelle 2009

${time} Heure actuelle 15h15

${file_name} Nom du fichier créé HelloWorld.mxml

${project_name} Nom du projet Flex ou ActionScript Hello_World_Project

${utilisateur} Nom d’utilisateur de l’auteur jdoe

${dollar}

Symbole du dollar $

Variables des modèles pour les fichiers MXML

Variable Description Exemple

${application}

${component}

${module}

${xml_tag} Version XML

${xmlns} Correspond à la définition d’espace de

Spécifient les noms des balises de l’application, du composant ou du module MXML.

Pour une application Web, ${application} s’étend à « Application ».

Pour une application de bureau, ${application} s’étend à « WindowedApplication ».

${component} s’étend à « Component ».

${module} s’étend à « Module ».

Ces balises permettent généralement de positionner les balises d’ouverture et de fermeture d’un fichier.

noms en fonction du type de SDK Flex du projet et du préfixe d’espace de noms défini dans les Préférences.

Les balises suivantes :

<${application} ${xmlns}${wizard_attributes}${min_size}> ${wizard_tags}

</${application}>

s’étendent à :

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spa rk" xmlns:mx="library://ns.adobe.com/flex/ha lo" minWidth="1024" minHeight="768"> <s:layout> <s:BasicLayout/> </s:layout>

</s:Application>

<?xml version="1.0" encoding="utf-8"?>

Pour un projet SDK Flex 4 :

xmlns="http://ns.adobe.com/mxml/2009"

${min_size} Taille minimale d’une application Web

MXML.

${ns_prefix} Préfixe d’espace de noms pour le SDK Flex

du projet.

Vous ne pouvez pas modifier les valeurs par défaut de cette variable.

Dernière mise à jour le 8/7/2011

minWidth="1024" minHeight="768"

Pour Flex 3 :

Pour Flex 4 : fx:

mx:

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Variable Description Exemple

${wizard_attributes} Spécifie la position des attributs définis

par l’assistant Nouveau Fichier.

${wizard_tags} Spécifie la propriété de présentation des

conteneurs définis par l’assistant Nouveau Fichier.

${fx} Préfixe pour l’espace de noms du

document de langage MXML 2009. Le préfixe est défini dans le document MXML.

Pour une nouvelle application Web :

${application} ${xmlns}${wizard_attributes}>

s’étendent à :

Pour une nouvelle application basée sur le SDK Flex 4 :

<s:layout>

<s:BasicLayout/>

</s:layout>

Lorsque le modèle de balise de bibliothèque suivant apparaît dans un document MXML :

<${fx}Library> <${fx}Definition id="${def}"> ${cursor} </${fx}Definition> </${fx}Library>

Une balise de bibliothèque est créée comme suit :

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Variable Description Exemple

${mx} Préfixe pour l’espace de noms du

document MX. Le préfixe est défini dans le document MXML.

${s} Préfixe pour l’espace de noms du

document Spark

${tag} Nom complet de balise pour les

composants MX du projet.

Lorsque vous utilisez le modèle Combobox suivant dans le contexte des composants MX :

<${mx}ComboBox id="${comboBox}" rowCount="${rowCount:values(5)}" dataProvider="${dataProvider}"/> ${cursor}

Un élément Combobox est créé comme suit :

<mx:ComboBox id="comboBox" rowCount="5" dataProvider="dataProvider"/>

Lorsque vous utilisez le modèle Spark Button suivant dans le contexte des composants Spark :

<${s}Button id="${btn}" label="${myButton}" click="${onClick}(${event})"/> ${cursor}

Un bouton Spark est créé comme suit :

<s:Button id="btn" label="myButton" click="onClick(event)"/>

Lorsque vous utilisez le modèle List dans le contexte MXML :

<${list:tag(mx.controls.List)} id="${myList}"> <${dp:tag(dataProvider)}>

<${arraycollection:tag(mx.collections.Ar rayCollection)}> ${cursor} </${arraycollection}> </${dp}> </${list}>

Une liste est créée comme suit :

<s:List id="myList"> <s:dataProvider> <s:ArrayCollection> </s:ArrayCollection> </s:dataProvider> </s:List>

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Variables des modèles pour les fichiers ActionScript

Variable Description Exemple

${package_declaration} Génère la déclaration du package. Pour un fichier du package com/samples,

génère :

package com.samples

${import_declaration} Génère les déclarations d’importation requises

pour une nouvelle classe ou interface ActionScript.

${interface_declaration} Génère la déclaration d’interface pour une

nouvelle interface ActionScript.

Pour une sous-classe de TextBox, génère :

import flex.graphics.TextBox;

Pour une nouvelle interface qui étend l’interface IButton, génère :

public interface IMyButton extends IButton

${class_declaration} Génère la déclaration de classe pour une

nouvelle classe ActionScript.

Pour une nouvelle sous-classe de CheckBox, génère :

public class MyCheckBox extends CheckBox

${class_body} Génère toutes les instructions requises pour

une nouvelle classe.

Pour une nouvelle sous-classe de Button implémentant l’interface IBorder, génère ce qui suit pour le corps de la classe :

public function MyButton() { super(); } public function get borderMetrics():EdgeMetrics { return null; }

${interface_name}

${class_name}

${package_name}

Spécifie le nom de l’interface, de la classe ou du package.

Cette variable est utilisée généralement lors de la création de commentaires.

Par exemple, la spécification de modèle :

/* * ${class_name} implements. . . */

génère le code :

/* * MyButton implements. . . */

${array} Indique la valeur d’un tableau Le modèle Fore suivant

for each (var ${index}:${type} in ${array}) { ${line_selection} ${cursor} }

réalise une itération sur la valeur d’un tableau à l’aide d’une énumération comme suit :

for each (var i:type in array) { }

${enclosing_method} Indique le nom de la méthode englobante Le modèle traceMethod effectue le suivi

de la méthode comme suit :

trace("${enclosing_type}.${encl osing_method} ${enclosing_method_arguments})" );

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Variable Description Exemple

${enclosing_package} Indique le nom du package, tel que « xx.yy » de

« xx.yy.class »

${enclosing_type} Indique le nom du type, tel que « class » de

« xx.yy.class »

Le modèle package crée un package comme suit :

package ${enclosing_package} { /** * @author ${user} */ class ${enclosing_type} { ${cursor} } }

Le modèle package crée un package indiquant le nom de classe comme suit :

package ${enclosing_package} { /** * @author ${user} */ class ${enclosing_type} { ${cursor} } }

${field} Indique les variables de classe Le modèle do créé la boucle « do-while »

comme suit :

do { ${line_selection} ${cursor} } while (${condition:local_var(Boolean) });

${local_var} Spécifie la variable locale qui est visible dans le

bloc

Le modèle if crée une instruction if comme suit :

if (${condition:local_var(Boolean) }) { ${cursor} }

${var} Spécifie toutes les variables visibles Le modèle fori réalise une itération sur la

valeur d’un tableau comme suit :

for (var ${index}:int = 0; ${index} < ${array}.length; ${index}++) { ${cursor} }

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Variables des modèles pour les fichiers CSS

Variable Description Exemple

${css_namespaces} Définit les espaces de noms pour les

sélecteurs de style Spark et Halo.

Valeurs par défaut pour Flex 3 :

(Dans Flex 3, les déclarations d’espace de noms ne sont pas requises dans les fichiers CSS).

Valeurs par défaut pour Flex 4 :

@namespace s "library://ns.adobe.com/flex/spark"; @namespace mx "library://ns.adobe.com/flex/halo";

Exemples de fichiers de modèle

Les codes suivants illustrent un exemple de modèle de fichier de composant MXML, suivi par un nouveau fichier de composant MXML généré à partir du modèle.

Exemple de modèle pour un fichier de composant MXML

--> <${component} ${xmlns}${wizard_attributes}>

${wizard_tags}

<${ns_prefix}Script> <![CDATA[

]]> </${ns_prefix}Script>

</${component}>

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Nouveau fichier de composant MXML généré à partir du modèle d’exemple

-->

<s:Group xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/halo" width="400" height="300">

<s:layout>

<s:BasicLayout/>

</s:layout>

<fx:Script>

<![CDATA[

]]>

</fx:Script>

</s:Group>

Génération à partir de l’utilisation

L’Assistant rapide permet de générer du code de remplacement pour une méthode, une variable ou une classe non définie dans le code. Le code de remplacement généré peut être utilisé comme espace réservé pour le code que vous souhaitez implémenter plus tard sans rendre votre code incompatible. Pour personnaliser le code de remplacement prédéfini généré par Flash Builder, voir « Modèles de code » à la page 56.

Pour appeler l’Assistant rapide, vous pouvez utiliser le raccourci clavier Ctrl+1(Windows) ou Commande+1 (Mac OS).

Utilisez l’Assistant rapide pour générer un code de remplacement dans la classe appropriée ou un bloc de script MXML en sélectionnant une des actions suivantes :

Générer la méthode Crée une méthode

Par exemple, si vous avez le code suivant :

private function genFunc():void { bar(); }

Placez votre curseur à n’importe quel endroit sur la ligne de code contenant bar();, puis appuyez sur Ctrl+1. Une option permettant de créer une fonction apparaît. Lorsque vous sélectionnez cette option, une nouvelle fonction est générée comme suit :

private function bar():void{}

Vous pouvez également générer une fonction pour une fonction non définie dans une classe référencée. Par exemple, si vous avez une fonction non définie « setValue() » dans la classe référencée « MyClass », comme suit :

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

MyClass cls = new MyClass(); cls.setValue(5);

Placez votre curseur à n’importe quel endroit sur la ligne de code contenant « setValue », puis appuyez sur Ctrl+1. Une option permettant de créer une fonction apparaît. Lorsque vous sélectionnez cette option, une nouvelle fonction

setValue(int) est générée dans la classe « MyClass » référencée, comme suit :

private function setValue(param0:int):void {

// TODO Auto Generated method stub

}

Générer une variable Crée une propriété

Par exemple, si dans votre code,

public function MyClass {

}

i est une variable non définie, comme suit :

Placez votre curseur à n’importe quel endroit sur la ligne de code contenant i;, puis appuyez sur Ctrl+1. Des options permettant de créer une variable locale ou un champ apparaissent.

Sélectionner l’option qui permet de créer une variable locale a pour effet de créer la variable comme suit :

var i:Object;

Sélectionner l’option qui permet de créer un champ a pour effet de créer une variable au niveau de la classe, comme suit :

private var i:Object;

Vous pouvez également générer une propriété pour une variable non définie dans une classe référencée. Par exemple, si vous avez une variable non définie « aValue » dans la classe référencée « MyClass », comme suit :

MyClass cls = new MyClass(); cls.aValue = "str";

Placez votre curseur à n’importe quel endroit sur la ligne de code contenant aValue, appuyez sur Ctrl+1, puis sélectionnez Créer la variable de champ. Une propriété

aValue de type chaîne est générée dans la classe « MyClass »

référencée, comme suit :

private var aValue:String;

Générer une classe/interface Crée une classe ou une interface

Par exemple, si dans votre code,

public function myFunction():Foo;

{ }

Foo est une variable non définie, comme suit :

Placez votre curseur à n’importe quel endroit sur la ligne de code contenant Foo;, puis appuyez sur Ctrl+1. Des options permettant de créer une classe ou une interface nommée

Foo apparaissent. Sélectionnez une de ces options pour ouvrir

l’assistant de création d’une classe ActionScript ou l’assistant de création d’une interface ActionScript. Entrez les détails nécessaires et cliquez sur Terminer. Après avoir cliqué sur Terminer, une classe ou interface nommée

Foo est

créée.

Lorsque vous générez une nouvelle classe, vous pouvez créer une classe ActionScript avec un constructeur paramétré.

Par exemple, si votre code ressemble au suivant :

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Private function func(): void {

New NewClass("str1");

}

Placez votre curseur à n’importe quel endroit sur la ligne de code contenant NewClass("str1"), appuyez sur Ctrl+1, puis sélectionnez Créer la classe. Une classe ActionScript avec un constructeur paramétré est créée. Toutefois, si vous spécifiez une superclasse pour la classe ActionScript, aucun constructeur paramétré n’est généré.

Paul Robertson, professionnel de la communauté Adobe, a publié sur son blog un article concernant l’utilisation de

Quick Assist pour les classes externes et les interfaces.

Générer un gestionnaire d’événement Génère des fonctions de gestionnaire d’événement

Par exemple, si votre code ressemble au suivant :

public function MyClass

{

Var button:Button = new Button(); button.addEventListener(DragEvent.DRAG,dragHandlerFunction);

}

Placez votre curseur à n’importe quel endroit sur la ligne de code contenant dragHandlerFunction, puis appuyez sur Ctrl+1. Sélectionnez ensuite l’option de l’Assistant rapide permettant de créer le gestionnaire d’événement. La fonction du gestionnaire d’événement est créée comme suit :

protected function dragHandlerFunction (event:DragEvent):void { }

Générer l’instruction d’importation de l’utilisation Créer une instruction d’importation

Par exemple, si vous avez un code dans lequel le type de variable

<fx:Script>

<![CDATA[

var btn:Button;

]]>

</fx:Script>

Button n’est pas défini, comme suit :

Placez votre curseur à n’importe quel endroit sur la ligne de code contenant var btn:Button, puis appuyez sur Ctrl+1. Une option d’importation de

Button apparaît si une classe nommée Button est disponible dans le projet.

L’instruction d’importation est créée comme suit :

import spark.components.Button;

Vous pouvez générer des instructions d’importation pour les arguments de fonction, les types de retour de fonction, etc.

Génération de fonctions d’accesseur Get ou Set

Les fonctions des accesseurs Get et Set permettent de faire en sorte que les propriétés d’une classe restent privées pour cette classe. Les utilisateurs peuvent accéder à ces propriétés de la même manière qu’ils accèdent à une variable de classe (au lieu d’appeler une méthode de classe).

Pour plus d’informations sur les méthodes d’accesseur Get et Set, voir Méthodes d’accesseur Get et Set dans Guide de

référence du langage ActionScript 3.0 pour la plateforme Adobe Flash.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Flash Builder peut générer des fonctions d’accesseur Get et Set ActionScript pour les variables de classe. Vous pouvez sélectionner une propriété liable et générer des fonctions d’accesseur Get et Set pour cette propriété. Vous pouvez également spécifier un nom d’événement personnalisé pendant la génération du code.

Lorsque vous générez des accesseurs Get et Set, Flash Builder propose les options suivantes :

• Rendre la variable de classe privée.

En règle générale, les variables de classe ont un accès privé.

• Renommer la variable de classe, en suggérant un trait de soulignement au début du nom.

Par convention, les variables de classe privée ont un trait de soulignement au début du nom.

• Renommer les fonctions d’accesseur.

• Spécifier une propriété liable et un nom d’événement personnalisé.

Lorsque vous spécifiez une propriété liable, une balise générée dans le code généré.

[Bindable] est définie au-dessus de la fonction d’accesseur

• Préciser si vous voulez générer des fonctions d’accesseur Get et Set.

• Spécifier la valeur de l’espace de noms pour la fonction d’accesseur.

• Spécifier le placement de la fonction d’accesseur dans l’un des emplacements suivants :

• Avant la première méthode

• Après la dernière méthode

• Avant les déclarations de variable

• Afficher un aperçu du code qui est généré.

Pour personnaliser le code prédéfini généré par Flash Builder, voir « Modèles de code » à la page 56.

Génération de fonctions d’accesseur Get ou Set

1 Ouvrez un fichier ActionScript dans l’éditeur de source, puis placez le curseur sur une variable de classe.

2 Sélectionnez Source > Générer les méthodes Get/Set dans le menu Flash Builder ou le menu contextuel.

3 Dans la boîte de dialogue Générer les méthodes Get/Set, spécifiez les informations concernant les fonctions

d’accesseur puis cliquez sur OK.

Remarque : pour afficher le code qui est généré, sélectionnez Aperçu avant de cliquer sur OK.

Vérification de la syntaxe

Au cours de la rédaction de code, le compilateur Flash Builder identifie les erreurs de syntaxe et les signale pour vous permettre de les corriger avant d’exécuter l’application. Les couleurs de la syntaxe peuvent être personnalisées.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Lorsqu’une erreur de syntaxe est détectée dans le code, elle vous est signalée de l’une des manières suivantes.

• Un indicateur d’erreur apparaît en regard de la ligne de code, ainsi que l’illustre l’exemple suivant.

• La vue Structure signale les erreurs par un point d’exclamation affiché dans les lignes de code concernées, ainsi que

l’illustre l’exemple suivant.

• La vue Erreurs répertorie les erreurs en leur attribuant un symbole et en affichant le message correspondant.

Double-cliquez sur le message d’erreur pour localiser et mettre en évidence la ligne de code dans l’éditeur, ainsi que l’illustre l’exemple suivant.

Les erreurs de syntaxe du code sont détectées au cours de la génération des projets. Si elles ne sont pas corrigées avant l’exécution de l’application, un message vous avertit de l’existence d’erreurs. En fonction de la nature et de la gravité des erreurs, il est possible que l’application ne soit exécutée correctement qu’après correction de ces erreurs.

Application des préférences de couleurs pour la syntaxe

❖ Ouvrez la boîte de dialogue Préférences et sélectionnez Flash Builder > Editeurs > Couleurs pour la syntaxe.

Les couleurs par défaut peuvent également être définies dans les pages Editeurs de texte et Couleurs et polices des Préférences (voir Préférences > Général > Apparence > Couleurs et polices ; voir également Préférences > Général > Editeurs > Editeurs de texte).

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Mise en surbrillance des erreurs de référence non identifiée

Lorsque vous saisissez du code ActionScript, Flash Builder génère automatiquement des annotations d’erreur pour les identifiants non définis de votre code. Les annotations d’erreur sont indiquées par .

Vous pouvez rapidement identifier les variables et méthodes non définies avant d’enregistrer le fichier et que le compilateur ne génère l’erreur.

La mise en surbrillance des erreurs de référence non identifiées vous permet également d’identifier les endroits dans le code où vous pouvez générer du code de remplacement pour une méthode, une variable ou une classe non définie. Pour plus d’informations, voir « Génération à partir de l’utilisation » à la page 71.

Flash Builder active par défaut la mise en surbrillance des erreurs de référence non identifiée. Pour la désactiver, sélectionnez Flash Builder > Editeurs dans la boîte de dialogue Préférences, puis désélectionnez Signaler les erreurs au fur et à mesure de la saisie.

Recherche de références et restructuration du code

Flash Builder comporte des fonctions de recherche avancées plus puissantes que les fonctions de recherche/remplacement. Afin de faciliter la compréhension de la manière dont les fonctions, variables et autres identifiants sont utilisés, Flash Builder permet de rechercher et de repérer les références ou les déclarations vers les identifiants dans les fichiers ActionScript ou MXML, les projets ou les espaces de travail. Vous pouvez utiliser la restructuration pour renommer les identifiants suivants dans votre code et mettre à jour toutes les références à ces objets :

• Variables

• Fonctions

• Types (interface, classe)

• Accesseurs (getter/setter)

• Attributs

• Métadonnées en MXML (effets, événements, styles)

Marquage des références

1 En mode Source, cliquez sur le bouton Marquage des occurrences de la barre d’outils.

2 Dans l’éditeur, cliquez sur un identifiant. Toutes les occurrences sont marquées en fonction des paramètres des

Préférences.

Pour modifier l’apparence des références marquées, sélectionnez Général > Editeurs > Editeurs de texte > Annotations. Pour plus d’informations sur les marqueurs, voir « Utilisation de marqueurs » à la page 83.

Recherche de toutes les références et de toutes les déclarations

1 En mode Source, cliquez sur un identifiant dans l’éditeur.

2 Dans le menu principal, sélectionnez Rechercher > Références ou Rechercher > Déclarations. Sélectionnez ensuite

Fichier, Projet ou Espace de travail. Les résultats apparaissent dans la vue Recherche.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Restructuration du code

1 En mode Source, cliquez sur un identifiant dans l’éditeur.

2 Dans le menu principal, sélectionnez Source > Restructurer > Renommer.

3 Entrez un nouveau nom.

Flash Builder vérifie que les conditions préalables à la modification du nom sont réunies et vous invite à confirmer les problèmes avant de procéder à la modification du nom. Les conditions préalables à la modification du nom sont les suivantes :

• Les références situées dans des fichiers en lecture seule ne peuvent pas être renommées.

• Tous les fichiers doivent avoir été sauvegardés.

• Les projets présentant des erreurs de génération provoquent l’affichage d’un avertissement.

• Le nouveau nom doit se trouver dans l’étendue, déterminée par le type de l’élément et son emplacement. Les

erreurs d’occultation de noms sont également signalées.

• Le nouveau nom doit être un identifiant valide.

• La référence définie dans un fichier SWC doit comprendre une connexion de la source.

4 Pour vérifier la modification apportée, cliquez sur Aperçu pour visionner la source d’origine et la source

restructurée, ou cliquez sur OK pour poursuivre la modification du code.

Restructuration dans les fichiers CSS

Lorsque vos fichiers CSS font référence à des fichiers ActionScript ou MXML et que vous renommez ou déplacez les fichiers ActionScript ou MXML, Flash Builder actualise automatiquement les fichiers CSS avec des références au nouveau nom ou au nouvel emplacement. Vous pouvez vérifier les modifications dans la boîte de dialogue Aperçu, puis cliquer sur OK pour appliquer la modification à votre code.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Formatage, navigation et organisation du code

Les éditeurs Flash Builder offrent de nombreuses fonctions pour parcourir le code. Vous pouvez par exemple réduire ou développer des blocs de code, ouvrir les sources de définitions de code ainsi que rechercher et ouvrir des types. La navigation par code offre la possibilité de sélectionner un élément de code (une référence à un composant personnalisé d’un fichier d’application MXML, par exemple) et d’aller à la source de la définition du code, quel que soit son emplacement dans le projet, espace de travail ou chemin.

Des blocs de plusieurs lignes peuvent être réduits et développés afin de faciliter la navigation, l’affichage et la gestion de documents présentant un code complexe. Dans Flash Builder, ces deux opérations sont désignées par les termes de développement et de réduction d’instructions de code de plusieurs lignes.

Formatage et mise en retrait du code

Lorsque vous saisissez du code, Flash Builder insère automatiquement des lignes de code pour améliorer la lisibilité, ajoute une couleur distinctive aux éléments de code et propose de nombreuses commandes de formatage rapide du code que vous saisissez (ajout d’un commentaire de bloc, par exemple).

Pour changer le formatage par défaut, dans la boîte de dialogue Préférences, sélectionnez Flash Builder > Code MXML > Formatage. Vous pouvez modifier l’ordre et le regroupement des attributs.

Lorsque vous collez du code MXML ou ActionScript dans l’éditeur de code, Flash Builder met automatiquement en retrait le code en fonction de vos préférences. Vous pouvez également spécifier une mise en retrait pour un bloc de code sélectionné.

Pour modifier les préférences de mise en retrait, dans la boîte de dialogue Préférences, sélectionnez Flash Builder > Editeurs. Vous pouvez spécifier le type et la taille de retrait.

Définition, réduction et développement des blocs de code

1 Dans l’éditeur, cliquez sur le symbole de réduction (-) ou sur celui de développement (+) dans la marge de gauche.

La réduction d’un bloc de code en masque toutes les lignes à l’exception de la première.

Développez le bloc de code pour en afficher à nouveau le contenu. Placez la souris sur le symbole de développement (+) pour visionner l’ensemble du bloc dans une info-bulle.

2 La réduction de code est activée par défaut dans Flash Builder. Pour la désactiver, ouvrez la boîte de dialogue

Préférences et sélectionnez Flash Builder > Editeurs. Désélectionnez ensuite l’option Réduction des codes.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Utilisation de la vue Structure pour parcourir et examiner le code

La vue Structure appartient à la perspective Développement Flash (voir « Perspective Développement Flash » à la page 8). Elle est donc disponible au cours de la modification du code et de la création de l’application. Cette vue permet d’examiner et de parcourir plus facilement la structure des documents MXML, ActionScript et CSS.

Elle présente trois modes : le mode Classe, le mode MXML et le mode CSS. En mode Classe, cette vue affiche la structure du code (classes, variables des membres, fonctions, etc.). En mode MXML, elle affiche la structure MXML (balises, composants, contrôles, etc.). En mode CSS, elle affiche les sélecteurs CSS et les propriétés imbriquées qu’ils contiennent.

La sélection d’un élément dans la vue Structure permet de le localiser et de le mettre en évidence dans l’éditeur, facilitant ainsi considérablement la navigation à l’intérieur du code.

Vue Structure en mode Classe

Lorsque vous éditez un document ActionScript (ou un code ActionScript contenu dans un document MXML), la vue Structure affiche la structure du code. Cette structure comporte les instructions d’importation, les packages, les classes, les interfaces, les variables non contenues dans les fonctions et les fonctions. En revanche, elle ne contient aucune métadonnée, aucun commentaire, aucune déclaration d’espace de noms et aucun contenu de fonction.

Les nœuds et les éléments de l’arborescence de la vue Structure représentent à la fois les différents types d’éléments de langage et leur visibilité. Les icônes rouges signalent par exemple des éléments privés ; les icônes vertes signalent des éléments publics ; les icônes jaunes indiquent que l’élément n’est ni privé, ni public.

Barre d’outils de la vue Structure en mode Classe

En mode Classe, la barre d’outils de la vue Structure contient les commandes de tri et de filtrage, ainsi que l’illustre l’exemple suivant :

Vue Structure en mode MXML

La vue Structure d’un document MXML en cours d’édition contenant du code MXML et du code ActionScript présente les modes Classe et MXML.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

En mode MXML, chaque élément de la vue représente une balise MXML. Les types de balise affichés sont les suivants : les composants, les contrôles, les balises non visuelles ( exprimées sous forme de balises enfant (contraintes de présentation, par exemple) et les balises de compilateur (

Array et Script).

WebService ou State), les propriétés des composants

Model,

Le mode MXML de la vue Structure n’affiche aucun commentaire, aucune règle ou propriété CSS et aucune propriété de composant exprimée sous forme d’attribut (par opposition aux balises enfant qui sont affichées).

Barre d’outils de la vue Structure en mode MXML

En mode MXML, la barre d’outils de la vue Structure contient des commandes supplémentaires permettant de basculer de la vue MXML à la vue des classes.

Pour basculer entre les deux vues, sélectionnez Afficher la vue MXML ou Afficher la vue des classes dans le menu de la barre d’outils.

Utilisation de la vue Structure rapide de l’éditeur

Vous pouvez ouvrir la vue Structure rapide à partir des éditeurs ActionScript et MXML pour afficher la vue Structure en mode Classe. La vue Structure rapide apparaît dans une fenêtre contextuelle à l’intérieur de l’éditeur et ne se présente donc pas sous forme de vue distincte. Elle permet de parcourir et d’examiner rapidement le code.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Son contenu est identique à celui du mode Classe, à ceci près que la Structure rapide présente une zone de saisie de texte permettant de filtrer les éléments affichés. Vous pouvez par exemple entrer le nom d’un élément dans la vue Structure rapide afin de limiter l’affichage aux éléments contenant les caractères saisis.

La vue Structure rapide ne contient pas les commandes permettant d’effectuer un tri alphabétique des éléments ou de les masquer.

De même que dans la vue Structure, vous pouvez sélectionner un élément afin de le localiser et de le mettre en évidence dans l’éditeur.

Ouverture de la vue Structure rapide

❖ Ouvrez un document ActionScript ou MXML dans l’éditeur. Dans le menu Naviguer, sélectionnez Structure

rapide.

Vous pouvez également utiliser le raccourci clavier Ctrl+O.

Fermeture de la vue Structure rapide

❖ L’accès à tout emplacement situé en dehors de la vue Structure rapide conduit à la fermeture de cette dernière. Elle

peut également être fermée en appuyant sur la touche Echap.

Ouverture des définitions de code

Quelle que soit la complexité des applications, les projets contiennent généralement de nombreuses ressources et lignes de code. Afin de parcourir et d’examiner plus facilement les différents éléments du code, vous pouvez ouvrir la source d’une définition de code externe à partir de l’emplacement, dans le code, auquel il y est fait référence. Si vous créez par exemple un composant MXML personnalisé et l’importez dans l’application MXML, vous pouvez sélectionner la référence au composant MXML et ouvrir le fichier source dans l’éditeur.

Ouverture de la source d’une définition de code

1 Dans l’éditeur, sélectionnez la référence du code.

2 Dans le menu Naviguer, sélectionnez Accéder à la définition.

Vous pouvez utiliser le raccourci clavier F3.

Le fichier source contenant la définition du code s’ouvre dans l’éditeur.

Flash Builder prend également en charge la navigation dans le code par hyperliens.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Ouverture de la source d’une définition de code en utilisant la navigation par hyperliens

1 Localisez la référence du code dans l’éditeur.

2 Appuyez sur la touche Ctrl (Windows) ou la touche Cmd (Mac OS) et maintenez-la enfoncée, puis positionnez le

curseur de la souris sur la référence du code pour afficher l’hyperlien.

3 Pour atteindre la référence du code, cliquez sur l’hyperlien.

Navigation et affichage des classes

La boîte de dialogue Ouvrir un type permet de parcourir toutes les classes disponibles (y compris les classes de la structure Flex) du projet. Dans la boîte de dialogue Ouvrir un type, sélectionnez une classe pour afficher l’implémentation.

Boîte de dialogue Ouvrir un type

La boîte de dialogue Ouvrir un type permet également de sélectionner des classes comme classe de base pour une nouvelle classe ActionScript ou un nouveau composant MXML.

La boîte de dialogue Ouvrir un type vous permet de filtrer les classes affichées en fonction du texte et des caractères génériques que vous spécifiez. La boîte de dialogue fait appel à différentes couleurs pour signaler les types recommandés et les types exclus. Les types recommandés sont affichés en gris. Les types exclus sont affichés en marron.

Les types recommandés sont les classes disponibles dans l’espace de noms par défaut d’un projet. Dans certains contextes par exemple, seuls les composants Spark sont autorisés. D’autres contextes autorisent les composants Spark et les composants Halo.

Les types exclus sont les classes qui ne sont pas disponibles dans l’espace de noms par défaut pour un projet.

Ouverture de la boîte de dialogue Ouvrir un type

• (Parcourir les classes) Pour parcourir les classes et visionner leur implémentation :

1 Dans le menu Flash Builder, sélectionnez Naviguer > Ouvrir un type.

2 (Facultatif) Saisissez du texte ou sélectionnez des filtres pour modifier les classes visibles dans la liste.

3 Sélectionnez une classe pour en afficher le code source.

Vous ne pouvez pas modifier le code source des classes dans la structure Flex.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

• (Nouvelles classes ActionScript) Pour sélectionner une classe de base pour une nouvelle classe ActionScript :

1 Sélectionnez Fichier > Nouveau > Classe ActionScript.

2 En regard du champ Superclasse, cliquez sur Parcourir.

3 (Facultatif) Saisissez du texte ou sélectionnez des filtres pour modifier les classes visibles dans la liste.

4 Sélectionnez une classe de base dans la liste.

• (Nouveaux composants MXML) Pour sélectionner un composant de base pour un nouveau composant MXML :

1 Cliquez sur Fichier > Nouveau > Composant MXML.

2 Dans la liste des projets de l’espace de travail, sélectionnez un projet pour un nouveau composant MXML et

spécifiez un nom pour le fichier.

Les composants de base disponibles varient en fonction des espaces de noms configurés pour un projet.

3 En regard du champ Basé sur, cliquez sur Parcourir.

Remarque : effacez ou modifiez la classe de base par défaut répertoriée dans le champ Basé sur pour élargir vos choix.

4 (Facultatif) Saisissez du texte ou sélectionnez des filtres pour modifier les classes visibles dans la liste.

5 Sélectionnez un composant de base dans la liste.

Affichage des numéros de ligne

Vous pouvez ajouter des numéros de ligne dans l’éditeur afin de faciliter la lecture et la consultation du code.

❖ Dans le menu contextuel de la marge de l’éditeur, sélectionnez Afficher les numéros de ligne.

La marge de l’éditeur se situe entre la barre de repère et l’éditeur.

Utilisation de marqueurs

Les marqueurs sont des raccourcis vers les lignes de code d’un document, vers un document ou vers un dossier. Ils représentent des tâches, des signets et des problèmes. Ils sont affichés et peuvent être gérés. La sélection de marqueurs provoque l’ouverture du document associé dans l’éditeur et met éventuellement en évidence la ligne concernée du code.

Pour mettre à jour les marqueurs de problèmes dans Flash Builder, vous devez enregistrer le fichier. Seuls les fichiers auxquels l’application fait référence sont vérifiés. La syntaxe d’une classe isolée qui n’est pas utilisée dans le code n’est pas contrôlée.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

Le workbench génère automatiquement les marqueurs de tâches et de problèmes suivants. Vous pouvez ajouter des tâches et des signets manuellement.

Tâches Les marqueurs de tâches représentent un élément de travail. Les éléments de travail sont générés

automatiquement par le workbench. Vous pouvez ajouter manuellement une tâche à une ligne de code du document ou au document même. Par exemple, afin de penser à définir une propriété pour un composant, vous pouvez créer une tâche nommée « Définir les propriétés de l’aspect ». Vous pouvez également ajouter des tâches générales qui ne s’appliquent pas directement aux ressources (« Créer un composant personnalisé pour l’invite de connexion de l’employé », par exemple). La vue Tâches permet de gérer tous les marqueurs de tâches. Pour plus d’informations, voir « Ajout de tâches » à la page 84.

Erreurs Les marqueurs d’erreurs sont générés par le compilateur et signalent différents types d’états non valides. Par

exemple, les erreurs de syntaxe et les avertissements générés par le compilateur sont affichés comme marqueurs dans la vue Erreurs. Pour plus d’informations, voir « Vue Erreurs » à la page 10.

Signets Vous pouvez ajouter manuellement des signets à une ligne de code ou à une ressource (dossier ou document).

Vous utilisez des signets pour leur côté pratique, afin de suivre les éléments de vos projets et de naviguer facilement jusqu’à eux. Ils sont gérés dans la vue Signets. Pour plus d’informations, voir « Ajout et suppression de signets » à la page 85.

Remarque : les vues Tâches et Signets ne sont pas affichées par défaut dans la perspective Développement Flash. Pour plus d’informations sur l’ajout de ces vues, voir « Utilisation de vues » à la page 19.

Navigation dans les marqueurs

Les marqueurs sont à la fois des descriptions et des liens vers des éléments des ressources d’un projet. Les marqueurs sont générés automatiquement par l’ordinateur pour indiquer des problèmes au niveau du code ou sont ajoutés manuellement pour vous aider à suivre les tâches ou les bouts de code. Les marqueurs sont affichés et gérés dans les vues associées. Les marqueurs d’un projet sont facilement repérables dans les vues Signets, Erreurs et Tâches, à partir desquelles ils sont accessibles.

Accès à l’emplacement d’un marqueur

❖ Sélectionnez un marqueur dans les vues Signets, Erreurs ou Tâches.

Le fichier contenant le marqueur est localisé et affiché dans l’éditeur. Si l’emplacement du marqueur est une ligne de code, cette dernière est mise en surbrillance.

Ajout de tâches

Les tâches sont des éléments de l’espace de travail créés automatiquement ou manuellement. Toutes les tâches sont affichées et gérées dans la vue Tâches (Fenêtre > Autres vues > Généralités > Tâches), ainsi que l’illustre l’exemple suivant.

Ajout d’une tâche à une ligne de code ou à une ressource

1 Ouvrez un fichier dans l’éditeur, puis repérez et sélectionnez la ligne de code à laquelle vous souhaitez ajouter une

tâche. Vous pouvez également sélectionner une ressource dans l’Explorateur de packages.

2 Dans la vue Tâches, cliquez sur le bouton Ajouter une tâche dans la barre d’outils.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

3 Entrez le nom de la tâche et sélectionnez une priorité (Elevée, Normale, Faible), puis cliquez sur OK.

Remarque : ainsi que vous pouvez le constater dans l’Explorateur de packages, la ressource ne signale pas qu’elle contient un marqueur. Vous pouvez visionner et gérer tous les marqueurs de tâches dans la vue Tâches.

Achèvement et suppression de tâches

Une fois achevée, une tâche peut être marquée comme ayant été terminée et peut éventuellement être supprimée de la vue Tâches.

Définition d’une tâche comme étant terminée

❖ Dans la vue Tâches, sélectionnez une tâche de la colonne, ainsi que l’illustre l’exemple suivant.

Suppression d’une tâche

❖ Dans la vue Tâches, accédez au menu contextuel d’une tâche et sélectionnez Supprimer.

Suppression de toutes les tâches terminées

❖ Dans la vue Tâches, accédez au menu contextuel et sélectionnez Supprimer les tâches terminées.

Ajout et suppression de signets

Les signets permettent de repérer et rechercher facilement des éléments au sein des projets. Tous les signets sont affichés et gérés dans la vue Signets (Fenêtre > Autres vues > Généralités > Signets), ainsi que l’illustre l’exemple suivant.

Ajout d’un signet à une ligne de code ou à une ressource

1 Ouvrez un fichier dans l’éditeur, puis localisez et sélectionnez la ligne de code à laquelle vous souhaitez ajouter un

signet.

2 Dans le menu principal, sélectionnez Editer > Ajouter un signet.

3 Saisissez le nom du signet et cliquez sur OK.

Une icône de signet ( ) apparaît en regard de la ligne de code.

Remarque : ainsi que vous pouvez le constater dans l’Explorateur de packages, la ressource ne signale pas qu’elle contient un marqueur. Vous pouvez visionner et gérer tous les signets dans la vue Signets.

Suppression d’un signet

1 Dans la vue Signets, sélectionnez le signet à supprimer.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

2 Cliquez sur le signet avec le bouton droit de la souris (Windows) ou en appuyant sur la touche Ctrl (Mac OS), puis

sélectionnez Supprimer.

Organisation des instructions d’importation

L’utilisation de l’assistant de contenu dans les éditeurs MXML et ActionScript conduit à l’importation automatique dans le document des packages dans lesquels les classes se situent. Les packages sont ajoutés dans l’ordre dans lequel ils ont été saisis dans le code. Les importations qui ne sont pas utilisées ou ne sont pas nécessaires sont automatiquement supprimées.

Afin de faciliter l’organisation du code dans les documents ActionScript, vous pouvez trier les instructions d’importation par ordre alphabétique. Pour ce faire, ouvrez la boîte de dialogue Préférences, sélectionnez Flash Builder > Editeurs > Code ActionScript, puis Garder les importations organisées.

Tri des instructions d’importation

❖ Dans l’éditeur, ouvrez un document ActionScript contenant les instructions d’importation. Dans le menu Source,

sélectionnez Organiser les importations.

Vous pouvez également utiliser le raccourci clavier suivant : Ctrl+Maj+ O (Windows) ou Commande+Maj+O (Mac).

Ajout de commentaires et de blocs de commentaire

Vous pouvez ajouter ou supprimer des commentaires en utilisant les options dans le menu Source ou en faisant appel aux raccourcis clavier. Vous pouvez ajouter les types de commentaires suivants :

• Commentaires de source pour ActionScript (//)

• Commentaires de bloc pour ActionScript (/* */)

• Commentaires ASDoc pour ActionScript (/** */)

• Commentaires de bloc pour MXML ()

• Blocs CDATA pour MXML (<![CDATA[ ]]>)

Les commentaires ajoutés au code ActionScript peuvent être activés ou désactivés.

Paul Robertson, professionnel de la communauté Adobe, a publié sur son blog un article concernant l’utilisation

du mode de sélection des blocs.

Activer/désactiver les commentaires du code ActionScript

1 Dans l’éditeur, sélectionnez au moins une ligne de code ActionScript.

2 Appuyez sur Ctrl+Maj+C (Windows) ou Cmd+Maj+C (Mac OS) pour ajouter ou supprimer des commentaires de

style C.

3 Appuyez sur Ctrl+/ (Windows) ou Cmd+/ (Mac OS) pour ajouter ou supprimer des commentaires de style C++.

Ajout de commentaires XML à du code MXML

1 Dans l’éditeur, sélectionnez au moins une ligne de code MXML.

2 Appuyez sur Ctrl+Maj+C (Windows) ou Cmd+Maj+C (Mac OS) pour ajouter un commentaire.

Ajout de blocs CDATA à du code MXML

1 Dans l’éditeur, sélectionnez au moins une ligne de code MXML.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Outils de développement de code dans Flash Builder

2 Appuyez sur Ctrl+Maj+D (Windows) ou Cmd+Maj+D (Mac OS) pour ajouter un commentaire.

Mise en retrait de blocs de commentaire

L’éditeur met automatiquement en forme les lignes de code en cours de saisie, améliorant ainsi la lisibilité et facilitant la rédaction. Vous pouvez également utiliser la touche de tabulation pour mettre manuellement en retrait certaines lignes de code.

Lorsque vous copiez et collez des blocs de code dans Flash Builder, ce dernier met automatiquement en retrait le code en fonction de vos préférences.

Pour mettre en retrait un bloc de code en une seule opération, vous pouvez utiliser les commandes Décaler vers la droite et Décaler vers la gauche de l’éditeur.

Déplacement d’un bloc de code vers la gauche ou vers la droite

1 Dans l’éditeur, sélectionnez un bloc de code.

2 Cliquez sur Source > Décaler vers la droite ou Source > Décaler vers la gauche.

3 Appuyez sur la touche de tabulation ou sur Maj et la touche de tabulation pour mettre en retrait ou annuler la mise

en retrait de blocs de code.

Définition des préférences de la mise en retrait

1 Ouvrez la boîte de dialogue Préférences et sélectionnez Flash Builder > Mise en retrait.

2 Sélectionnez le type de mise en retrait (tabulations ou espaces) et spécifiez la taille de la mise en retrait ou des

tabulations.

Dernière mise à jour le 8/7/2011

Chapitre 4 : Utilisation des projets dans Flash Builder

Adobe® Flash® Builder™ vous permet de créer, gérer, assembler et distribuer des projets pour la création d’applications Web, de bureau et mobiles. Lorsque vous générez des fichiers SWC (shared component library), vous pouvez partager des composants et d’autres ressources entre diverses applications ou avec d’autres développeurs. Vous pouvez également utiliser différentes versions du SDK Flex d’Adobe directement dans Flash Builder.

Création de projets dans Flash Builder

Lorsque vous créez un projet, l’assistant Nouveau projet Flex vous guide à travers les différentes étapes et vous demande de préciser le type de projet à créer, le nom du projet, son emplacement ainsi que d’autres options.

Pour plus d’informations sur la création d’un projet ActionScript, voir « Création de projets ActionScript » à la page 91.

Pour plus d’informations sur la création de projets de bibliothèque, voir « Utilisation de projets de bibliothèque Flex » à la page 227.

Pour plus d’informations sur la création de projets Flash Professional, voir « Utilisation de Flash Builder avec Flash

Professional » à la page 245.

Création de projets Flex

Utilisez cette procédure pour créer des applications Web ou de bureau.

1 Sélectionnez Fichier > Nouveau > Projet Flex.

2 Entrez un nom de projet et un emplacement.

L’emplacement par défaut est l’espace de travail actuel.

3 Sélectionnez Web ou Bureau comme type d’application.

4 Utilisez le SDK Flex par défaut ou accédez à un autre SDK installé. Cliquez sur Suivant.

5 (Facultatif) Indiquez les paramètres du serveur.

Voir « Accès aux services de données » à la page 216.

6 Spécifiez un dossier de sortie.

Si vous ne spécifiez aucun serveur d’application, l’emplacement se trouve dans votre dossier du projet.

Si vous spécifiez un serveur d’application, le serveur de sortie se trouve hors du dossier du projet. En général, vous placez le dossier de sortie avec vos fichiers de service.

7 Cliquez sur Terminer ou sur Suivant pour indiquer d’autres options de configuration.

8 (Facultatif) Indiquez les chemins de génération.

Voir « Chemins de génération et autres options de configuration du projet » à la page 94.

9 Cliquez sur Terminer.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Utilisation des projets dans Flash Builder

Voir aussi

« Projets dans Flash Builder » à la page 33

Création d’un projet Flex utilisant uniquement des composants MX

Vous pouvez créer un projet Flex compatible avec les composants MX mis à disposition par Flex 3. L’option MX uniquement intervient lors de la création d’applications dont la conception est similaire aux applications créées avec une version antérieure de Flex, mais ayant malgré tout accès aux dernières fonctions de Flex et de Flash Builder (telles que la syntaxe d’états, les fonctionnalités CSS avancées, des fonctions de compilation améliorées ainsi que d’autres fonctionnalités de langage).

L’option MX uniquement ne met pas à la disposition des applications du projet les composants Spark.

Vous pouvez convertir un projet Flex en projet MX uniquement. Gardez cependant à l’esprit que Flash Builder ne réécrit pas le code du projet. Mettez manuellement à jour le code afin d’en supprimer toute référence aux composants Spark.

Création d’un projet Flex MX uniquement

1 Sélectionnez Fichier > Nouveau > Projet Flex.

2 Spécifiez l’emplacement du projet et les paramètres du serveur, comme le décrit la section « Chemins de génération

et autres options de configuration du projet » à la page 94.

3 Sur la page de génération des chemins de l’assistant Nouveau projet Flex, spécifiez MX uniquement.

4 Indiquez d’autres paramètres de génération de chemin, comme le décrit la section « Chemins de génération et

autres options de configuration du projet » à la page 94. Cliquez sur Terminer.

Conversion d’un projet Flex en projet Flex MX uniquement

1 Rendez le projet actif dans Flash Builder :

Pour ce faire, vous devez généralement ouvrir un fichier source du projet.

2 Sélectionnez Projet > Propriétés > Chemin de génération Flex.

3 Pour le paramètre Jeu de composants, sélectionnez l’option MX uniquement. Cliquez sur OK.

4 Modifiez tout code d’application du projet accédant à des composants Spark.

Il ne peut y avoir de références à des composants Spark dans un projet MX uniquement.

Création d’un projet Flex utilisant uniquement des composants Spark

Vous pouvez créer un projet Flex qui utilise uniquement des composants Spark. L’option Spark Only est utile pour créer des applications qui utilisent les fonctionnalités Flex et Flash Builder, telles que la nouvelle syntaxe d’états, les fonctionnalités CSS avancées, des fonctions de compilation améliorées ainsi que d’autres fonctionnalités de langage.

L’option Spark uniquement ne met pas à la disposition des applications du projet les composants MX fournis avec Flex 3.

Création d’un projet Flex Spark uniquement

1 Sélectionnez Fichier > Nouveau > Projet Flex.

2 Spécifiez l’emplacement du projet et les paramètres du serveur, comme le décrit la section « Création de projets

Flex » à la page 88.

3 Sur la page de génération des chemins de l’assistant Nouveau projet Flex, spécifiez Spark uniquement.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Utilisation des projets dans Flash Builder

4 Indiquez d’autres paramètres de génération de chemin, comme le décrit la section « Chemins de génération et

autres options de configuration du projet » à la page 94. Cliquez sur Terminer.

Création de projets Flex mobiles

Utilisez cette procédure afin de créer des applications AIR basées sur Flex exécutables sur les périphériques Apple iOS, BlackBerry Tablet OS et Google Android.

1 Sélectionnez Fichier > Nouveau > Projet mobile Flex.

2 Entrez un nom de projet et un emplacement.

L’emplacement par défaut est l’espace de travail actuel.

3 Utilisez le SDK Flex 4.5.1 par défaut qui prend en charge le développement d’applications mobiles. Cliquez sur

Suivant.

4 Spécifiez les paramètres mobiles :

• Sélectionnez la plateforme que votre application doit cibler. Pour plus d’informations, voir Plateformes cibles.

• Spécifiez un modèle d’application.

Pour plus d’informations, voir Modèles d’applications mobiles.

• Spécifiez les autorisations.

Sélectionnez la plateforme cible et définissez les autorisations pour chaque plateforme, le cas échéant. Vous pourrez modifier les autorisations par la suite dans le fichier XML descripteur de l’application.

Pour plus d’informations, voir Droits des applications mobiles.

• Spécifiez les paramètres de plateforme.

Les paramètres de plateforme vous permettent de sélectionner une gamme de périphériques cibles. Selon la plateforme sélectionnée, vous pouvez choisir le périphérique cible ou une gamme de périphériques cibles.

Remarque : il n’existe aucun paramètre spécifique aux plateformes Google Android et BlackBerry Tablet OS.

Pour plus d’informations, voir Paramètres de plateforme.

• Spécifiez les paramètres d’application.

Pour plus d’informations, voir Paramètres d’application.

5 Cliquez sur Terminer ou Suivant pour spécifier les paramètres du serveur.

6 (Facultatif) Indiquez les paramètres du serveur.

Pour plus d’informations, voir « Accès aux services de données » à la page 216.

7 Spécifiez un dossier de sortie.

Si vous ne spécifiez aucun serveur d’application, l’emplacement se trouve dans votre dossier du projet.

Si vous spécifiez un serveur d’application, le serveur de sortie se trouve hors du dossier du projet. En général, vous placez le dossier de sortie avec vos fichiers de service.

8 Cliquez sur Terminer ou sur Suivant pour indiquer d’autres options de configuration.

9 (Facultatif) Indiquez les chemins de génération.

Pour plus d’informations, voir « Chemins de génération et autres options de configuration du projet » à la page 94.

10 Cliquez sur Terminer.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Utilisation des projets dans Flash Builder

Brian Telintelo, consultant Flex, a publié un article concernant la création d’une application mobile pour la

plateforme Android.

Pour plus d’informations sur le développement mobile avec Flex et Flash Builder, voir Développement d’applications

mobiles avec Flex et Flash Builder.

Voir aussi

« Projets Flex mobiles » à la page 34

Création de projets ActionScript

Utilisez cette procédure pour créer des applications Web ou de bureau qui reposent sur les API de Flash ou d’Adobe AIR.

1 Sélectionnez Fichier > Nouveau > Projet ActionScript.

2 Entrez un nom de projet et un emplacement.

L’emplacement par défaut est l’espace de travail actuel.

3 Sélectionnez Web ou Bureau comme type d’application.

4 Spécifiez les chemins de génération.

Pour plus d’informations, voir « Chemins de génération et autres options de configuration du projet » à la page 94.

5 Cliquez sur Terminer.

Pour plus d’informations sur le codage dans ActionScript, consultez le Guide du développeur ActionScript.

Voir aussi

« Projets ActionScript » à la page 34

Création de projets ActionScript mobiles

Utilisez cette procédure afin de créer des applications AIR basées sur Flex exécutables sur les périphériques Apple iOS, BlackBerry Tablet OS et Google Android.

1 Sélectionnez Fichier > Nouveau > Projet mobile ActionScript.

2 Entrez un nom de projet et un emplacement.

L’emplacement par défaut est l’espace de travail actuel.

3 Utilisez le SDK Flex 4.5.1 par défaut qui prend en charge le développement d’applications mobiles. Cliquez sur

Suivant.

4 Spécifiez les paramètres mobiles :

• Sélectionnez les plateformes que votre application doit cibler.

Pour plus d’informations, voir Plateformes cibles.

• Spécifiez les autorisations de plateforme.

Pour plus d’informations, voir Droits des applications mobiles.

• Spécifiez les paramètres de plateforme.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Utilisation des projets dans Flash Builder

Pour plus d’informations, voir Paramètres de plateforme.

• Spécifiez les paramètres d’application.

Sélectionnez Réorientation automatique pour que l’application pivote lorsque le périphérique subit une rotation.

Sélectionnez Plein écran pour que l’application s’affiche en mode plein écran sur le périphérique.

5 Cliquez sur Terminer ou sur Suivant pour indiquer d’autres options de configuration.

6 (Facultatif) Indiquez les chemins de génération.

Voir « Chemins de génération et autres options de configuration du projet » à la page 94.

7 Cliquez sur Terminer.

Apprenez-en davantage sur la création d’une application mobile en ActionScript pour la plateforme Android de Randy Troppmann, professionnel de la communauté Adobe.

Voir aussi

« Projets ActionScript mobiles » à la page 35

« Gestion des configurations de lancement » à la page 120

Création de projets compatibles avec Flash Catalyst

Vous pouvez créer un projet Flex compatible avec Flash Catalyst.

Lorsque vous créez un projet compatible avec Flash Catalyst,

xmlns:fc="http://ns.adobe.com/flashcatalyst/2009" l’espace de noms est ajouté. Cet espace de noms vous

permet de créer des composants dans Flash Builder qui peuvent être utilisés dans Flash Catalyst. Flash Catalyst CS5.5 prend en charge un sous-ensemble de composants qui sont disponibles dans la structure Flex 4.5.

Le vérificateur de compatibilité Flash Catalyst est automatiquement activé pour un projet compatible avec Flash Catalyst (Projet > Flash Catalyst > Vérifier automatiquement la compatibilité). Si vous utilisez des ressources incompatibles ou introduisez des incompatibilité dans le projet, Flash Builder affiche les erreurs de compatibilité dans la vue Erreurs. Pour plus d’informations sur la création d’un projet compatible avec Flash Catalyst, voir Directives sur

la création d’un projet compatible avec Flash Catalyst.

Un projet compatible avec Flash Catalyst permet aux créateurs de collaborer et de travailler sur le même projet. Vous pouvez partager un projet compatible avec Flash entre Flash Builder et Flash Catalyst par le biais des fichiers FXP ou FXPL. Vous pouvez par ailleurs modifier un projet compatible avec Flash Catalyst directement dans Flash Builder. utilisez ce flux de travail si Flash Builder et Flash Catalyst sont tous les deux installés sur le même ordinateur.

Pour plus d’informations, voir « Utilisation de Flash Builder avec Flash Catalyst » à la page 250.

Voir aussi

Présentation des flux de travaux Flash Catalyst CS5.5 et Flash Builder 4.5

Création d’un projet compatible avec Flash Catalyst

1 Sélectionnez Fichier > Nouveau > Projet compatible Flash Catalyst.

2 Entrez un nom de projet et un emplacement.

L’emplacement par défaut est l’espace de travail actuel.

3 Utilisez le SDK Flex par défaut ou accédez à un autre SDK installé. Cliquez sur Suivant.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Utilisation des projets dans Flash Builder

4 Cliquez sur Terminer.

Vérification de la compatibilité pour un projet compatible avec Flash Catalyst

Vous pouvez exécuter les étapes suivantes pour vérifier que votre projet demeure compatible avec Flash Catalyst.

• Sélectionnez Projet > Flash Catalyst. Activez l’option Vérifier automatiquement la compatibilité.

• Sélectionnez Projet > Propriétés > Flash Catalyst. Activez Exécuter automatiquement le vérificateur de

compatibilité Flash Catalyst pour ce projet.

• Sélectionnez Projet > Flash Catalyst > Exécuter le vérificateur de compatibilité.

Modification d’un projet compatible avec Flash Catalyst

1 Une fois le projet sélectionné dans l’explorateur de packages, choisissez Projet > Flash Catalyst > Editer le projet

dans Flash Catalyst pour lancer Flash Catalyst.

2 Lorsque vous modifiez le projet dans Flash Catalyst, il est verrouillé dans Flash Builder afin d’éviter toute

modification conflictuelle.

3 Une fois que vous avez modifié le projet dans Flash Catalyst, enregistrez les modifications, puis quittez Flash

Catalyst.

Remarque : lors de la modification d’un projet compatible avec Flash Catalyst, si vous introduisez des incompatibilités, Flash Builder affiche les erreurs de compatibilité dans la vue Problèmes. Cliquez avec le bouton droit sur le problème pour en savoir plus sur l’erreur de compatibilité. Assurez-vous de résoudre toutes les erreurs de compatibilité dans Flash Builder avant d’ouvrir le projet dans Flash Catalyst.

4 Pour ouvrir le projet et le modifier dans Flash Builder, sélectionnez Projet > Flash Catalyst > Reprendre le travail

sur le projet.

Lorsque vous sélectionnez cette option, vous êtes invité à enregistrer les modifications effectuées dans Flash Catalyst. Cela ramène le projet récemment enregistré dans Flash Builder. En arrière plan, la version du projet exportée initialement à partir de Flash Builder est supprimée lorsque la version récemment enregistrée du projet est importée avec succès à partir de Flash Catalyst.

5 A tout moment au cours de l’édition du projet dans Flash Catalyst, vous pouvez ignorer les modifications et

retourner dans Flash Builder. Pour ce faire, sélectionnez Projet > Flash Catalyst > Annuler l’édition du projet dans Flash Catalyst.

Lorsque vous sélectionnez cette option, les éventuels changements apportés au projet dans Flash Catalyst sont annulés et la version originale du projet est ouverte. La version originale du projet est celle qui a été initialement ouverte dans Flash Catalyst. Avant de supprimer la version du projet ouverte dans Flash Catalyst, vous avez la possibilité d’enregistrer les modifications dans un fichier de projet différent à un autre emplacement.

Création de projets AIR

1 Ouvrez Flash Builder.

2 Sélectionnez Fichier > Nouveau > Projet Flex.

3 Entrez le nom du projet.

4 Dans Flex, les applications AIR sont considérées comme un type d’application. Vous disposez de deux types

d’application : une application Web qui s’exécute dans Adobe® Flash® Player et une application de bureau qui s’exécute dans Adobe AIR. Sélectionnez Application de bureau comme type d’application.

5 Spécifiez si nécessaire la technologie de serveur à utiliser avec l’application AIR. En l’absence de technologie de

serveur, sélectionnez Aucun/Autre, puis cliquez sur Suivant.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Utilisation des projets dans Flash Builder

6 Sélectionnez le dossier dans lequel vous souhaitez créer l’application. Le dossier affiché par défaut est bin-debug.

Cliquez sur Suivant.

Modifiez si nécessaire les chemins source et d’accès à la bibliothèque, puis cliquez sur Terminer pour créer le projet AIR.

Regardez la vidéo Développement de votre première application bureau avec Flash Builder de l’évangéliste Adobe

James Ward.

Chemins de génération et autres options de configuration du projet

Lorsque vous créez un projet Flex, vous pouvez en personnaliser la configuration. Toutes les étapes de configuration supplémentaires sont facultatives.

Remarque : vous pouvez modifier la configuration d’un projet après sa création. Pour ce faire, accédez au mode Source de l’éditeur de Flash Builder, puis sélectionnez Projet > Propriétés.

• Dossier source principal, Fichier de l’application principale et URL du dossier de sortie

Par défaut, Flash Builder place les fichiers source dans le dossier src du projet. Le nom par défaut du fichier de l’application MXML principale est le nom du projet. Ces valeurs par défaut peuvent être modifiées à la création du projet.

Lorsque vous créez un projet, Flash Builder exécute les fichiers d’application à partir d’une URL par défaut, en fonction des paramètres du projet. Spécifiez une URL de dossier de sortie pour remplacer les paramètres par défaut. L’URL de dossier de sortie est utile lorsque vous créez et déployez l’application sur le serveur de votre projet, mais que vous déboguez l’application sur un serveur Web. Vous spécifiez ensuite l’URL du serveur Web comme URL de dossier de sortie. Par exemple, si vous indiquez http://myserver/test.swf comme URL de dossier de sortie, une configuration de lancement est créée avec cette URL.

Voir « Définition d’un dossier de sortie de projet » à la page 106 et « Exécution et débogage des applications » à la page 120.

• Jeu de composants

En règle générale, tous les composants sont disponibles. Dans certains cas, vous pouvez ne spécifier que les composants MX. Voir « Jeu de composants (MX + Spark, Spark uniquement ou MX uniquement) » à la page 105.

• Liaison de la structure

Par défaut, les classes d’application de la structure Flex 4.5 utilisent la liaison dynamique. Les options suivantes sont également activées par défaut :

• Vérifier les condensés RSL (recommandé en production)

• Supprimer les RSL non utilisées

Remarque : cette option n’est pas disponible dans les structures Flex antérieures à Flex 4.5.

• Utiliser les bibliothèques RSL locales de débogage lors du débogage

• Déterminer automatiquement l’ordre de la bibliothèque, en fonction des dépendances

Pour plus d’informations, voir « Liaison de la structure des applications » à la page 105.

• Bibliothèques du chemin de génération

Vous pouvez ajouter au chemin de génération des bibliothèques de projet, des dossiers de bibliothèque SWC ou des fichiers SWC ; vous pouvez également les en supprimer. Vous pouvez en outre modifier l’ordre du chemin de génération.

Cliquez sur le bouton Editer pour modifier l’emplacement des bibliothèques ou des dossiers ajoutés.

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Utilisation des projets dans Flash Builder

Utilisez le bouton Ajouter un SDK Flex pour rétablir le SDK par défaut d’un projet dont vous avez supprimé le SDK Flex du chemin de génération.

• Dossiers source supplémentaires

Cliquez sur l’onglet Chemin source pour ajouter des dossiers source supplémentaires à un projet. Vous pouvez réorganiser les dossiers source, en modifier l’emplacement ou les supprimer du chemin source.

Exportation et importation de projets

Flash Builder exporte les projets Flex au format FXP et les projets de bibliothèque Flex au format FXPL. Les projets ActionScript peuvent être exportés uniquement vers des fichiers archive, généralement au format ZIP.

Le format FXP est un format d’archive contenant les dossiers, les fichiers et les métadonnées d’un projet. Un projet exporté contient tous les projets de bibliothèque Flex dépendants.

Remarque : vous pouvez également faire appel à l’assistant d’exportation Eclipse pour exporter des projets Flex et des projets de bibliothèque Flex au format ZIP (utilisés dans Flex Builder 3) ou vers un autre format d’archive.

Lors de l’exportation ou de l’importation d’un projet Flex, certains contenus du projet nécessiteront un traitement spécial.

• Versions différentes du SDK Flex

Vous pouvez importer un projet Flex faisant référence à une version du SDK Flex qui n’a pas été installée avec Flash Builder. Pour plus d’informations sur le téléchargement et l’installation de versions supplémentaires du SDK Flex, voir « SDK Flex installés » à la page 269.

Si Flash Builder ne trouve pas une version spécifique du SDK Flex, une boîte de dialogue s’ouvre vous permettant de la rechercher.

Après avoir installé la version correcte du SDK Flex, accédez à son emplacement.

• Fichiers de services

Les projets de serveur Flex qui se connectent aux services de données, tels que ColdFusion ou BlazeDS, contiennent un dossier du projet, Flash Builder exporte le dossier services, mais vous devez vous assurer qu’un serveur et les fichiers côté serveur correspondants existent lors de l’importation. Après une importation, vous pouvez être amené à déployer manuellement les fichiers côté serveur et à mettre à jour les adresses du serveur dans les classes, dans les fichiers côté serveur.

Pour les projets se connectant aux services via LiveCycle Data Services ou BlazeDS, vérifiez que les destinations de service sont disponibles sur le serveur cible.

Pour les projets qui référencent des fichiers locaux, déployez ces derniers en utilisant le même chemin que celui du projet d’origine à l’importation. Cette manière de procéder s’applique aux projets accédant à des fichiers de service XML statiques ou à des fichiers locaux pour des services HTTP ou Web.

services dont la référence de classe ActionScript a déployé les fichiers de serveur. Lors de l’exportation

• Structure Zend Framework

Les projets Flex qui se connectent à des services de données en utilisant PHP et la structure Zend Framework contiennent deux fichiers de configuration. A l’importation, examinez ces fichiers afin de vérifier qu’ils ont été correctement configurés pour votre système :

amf-config.ini

Dernière mise à jour le 8/7/2011

UTILISATION DE FLASH BUILDER 4.5

Utilisation des projets dans Flash Builder

gateway.php

Pour plus d’informations sur l’installation, la configuration et le dépannage de votre installation Zend Framework, voir Installation de Zend Framework.

• Fichiers de modèles de données (LiveCycle Data Services)

Un projet Flex utilisant LiveCycle Data Services (LCDS) est relié à un fichier de modèle de données.

Après exportation puis importation, Flash Builder référence le fichier de modèle de données actuel et non le lien qui y renvoie. Si vous souhaitez utiliser un fichier lié (et non celui inclus dans le projet exporté), modifiez le fichier de modèle de données en accédant aux propriétés du projet. Sélectionnez Projet > Propriétés > Modèle de données pour apporter les modifications.

Exportation d’un projet Flex ou d’un projet de bibliothèque Flex au format FXP

Certains projets Flex devront faire l’objet d’un traitement spécial à l’importation. Voir « Exportation et importation de

projets » à la page 95.

1 Dans Flash Builder, sélectionnez Fichier > Exporter un projet Flash Builder.

Vous pouvez également faire appel au menu contextuel du projet dans l’Explorateur de packages. Sélectionnez Exporter > Flash Builder > Projet Flash Builder.

2 Dans l’assistant Exportation d’un projet Flex, sélectionnez le projet à exporter.

La liste déroulante Projet répertorie tous les projets disponibles.

3 (Facultatif) Activez l’option Valider la compilation du projet.

Sélectionnez cette option pour obtenir confirmation que le projet sera compilé sans erreurs. La présence d’erreurs ne vous empêchera pas de poursuivre l’exportation.

4 Cliquez sur Terminer.

Pour les projets sur serveur, les chemins absolus vers les ressources du serveur sont enregistrés sous forme de variables de chemin. Lorsque vous importerez ultérieurement le projet, vous devrez spécifier des valeurs pour les variables de chemin.

Exportation d’un projet ActionScript au format ZIP (ou vers tout autre format d’archive)

1 Dans Flash Builder, sélectionnez Fichier > Exporter > Autre.

2 Dans l’assistant d’exportation, sélectionnez Général > Fichier archive. Cliquez sur Suivant.

3 Sélectionnez le projet et les fichiers à exporter :

• Dans le volet de gauche, développez le projet pour en sélectionner les dossiers à inclure dans l’exportation.

• Dans le volet de droite, indiquez pour chaque dossier sélectionné les fichiers à exporter.

4 Recherchez un emplacement dans lequel enregistrer le projet exporté et attribuez un nom au fichier.

5 Définissez les options pour le fichier archive, puis cliquez sur Terminer.

Dernière mise à jour le 8/7/2011

ADOBE FLASH BUILDER 4.5 User Manual

Specifications and Main Features

Frequently Asked Questions

User Manual

Informations juridiques

Sommaire

Chapitre 1 : A propos de Flash Builder

Applications que vous pouvez créer à l’aide de Flash Builder

Fonctionnalités qui accélèrent le développement d’applications

Fonctionnalités d’exécution et de débogage de projets

Versions de Flash Builder

Configurations Flash Builder

Client de l’Aide de la communauté Adobe

Chapitre 2 : Initiation à Flash Builder

Workbench Flash Builder

Perspectives et vues de Flash Builder

Perspective Développement Flash

Perspective Développement Flash en mode Source

Perspective Développement Flash en mode Création

Autres vues utiles du workbench

Vue Signets

Vue Recherche

Utilisation de perspectives

Définition de la perspective par défaut

Ouverture de perspectives dans une nouvelle fenêtre

Personnalisation d’une perspective

Suppression d’une perspective personnalisée

Réinitialisation des perspectives

Utilisation de vues

Déplacement et ancrage de vues

Réorganisation des onglets de vue

Changement de vues

Création et utilisation des vues rapides

Filtrage des vues Tâches et Erreurs

Editeurs Flash Builder

Utilisation de l’éditeur MXML en mode Création

Affichage du fichier MXML en mode Création

Panoramique et défilement dans la zone de création

Zoom dans la zone de création

Actualisation du mode Création pour un rendu correct

Utilisation simultanée des modes Source et Création

Utilisation de composants visuels en mode Création MXML

Utilisation de la vue Composants

Ajout de composants en mode Création MXML

Sélection et déplacement de composants dans la zone de création

Sélection et désélection de plusieurs composants

Positionnement des composants

Dimensionnement des composants

Utilisation de l’accrochage pour positionner les composants

Alignement de composants

Ajustement de composants

Masquage des bordures de conteneurs

Définition des propriétés des composants

Copie de composants dans d’autres fichiers MXML

Suppression de composants

Inspection de la structure de votre MXML

Utilisation de composants visuels en mode Source MXML

Association d’éditeurs à des types de fichier

Edition de fichiers en dehors du workbench

Mosaïque d’éditeurs

Agrandissement d’une vue ou d’un éditeur

Projets dans Flash Builder

Types de projets

Projets Flex

Projets Flex mobiles

Projets ActionScript

Projets ActionScript mobiles

Projets de bibliothèque Flex

Projets compatibles avec Flash Catalyst

Projets Flash Professional

Gestion de projets

Projets dans l’Explorateur de packages

Déplacement d’un projet d’un espace de travail vers un autre

Spécification du SDK d’un projet

Suppression de projets

Fermeture et ouverture de projets

Changement du fichier de l’application principale

Gestion des fichiers d’application du projet

Changement de l’espace de travail

Définition des propriétés des projets Flex