ADOBE FLASH BUILDER 4 User Manual

Utilisation de

ADOBE® FLASH® BUILDER 4

Dernière mise à jour le 29/4/2010

Utilisation d’Adobe

If this guide is distributed with software that includes an end-user agreement, this guide, as well as the software described in it, is furnished under license and may be used or copied only in accordance with the terms of such license. Except as permitted by any such license, no part of this guide may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, recording, or otherwise, without the prior written permission of Adobe Systems Incorporated. Please note that the content in this guide is protected under copyright law even if it is not distributed with software that includes an enduser license agreement.

The content of this guide is furnished for informational use only, is subject to change without notice, and should not be construed as a commitment by Adobe Systems Incorporated. Adobe Systems Incorporated assumes no responsibility or liability for any errors or inaccuracies that may appear in the informational content contained in this guide.

Please remember that existing artwork or images that you may want to include in your project may be protected under copyright law. The unauthorized incorporation of such material into your new work could be a violation of the rights of the copyright owner. Please be sure to obtain any permission required from the copyright owner.

Any references to company names in sample templates are for demonstration purposes only and are not intended to refer to any actual organization.

Adobe, the Adobe logo, ActionScript, ColdFusion, Flash, Flash Builder, Flex, and Flex Builder are either registered trademarks or trademarks of Adobe Systems Incorporated in the United States and/or other countries.

Windows is either a registered trademark or trademark of Microsoft Corporation in the United States and/or other countries. Java is a trademark or registered trademark of Sun Microsystems, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.

This Work is licensed under the Creative Commons Attribution Non-Commercial 3.0 License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/

This product includes software developed by the Apache Software Foundation (

This product includes software developed by the OpenSymphony Group (

This product contains either BSAFE and/or TIPEM software by RSA Data Security, Inc.

The Flash Builder 3 software contains code provided by the Eclipse Foundation (“Eclipse Code”). The source code for the Eclipse Code as contained in Flash Builder 3 software (“Eclipse Source Code”) is made available under the terms of the Eclipse Public License v1.0 which is provided herein, and is also available at http://www.eclipse.org/legal/epl-v10.html.

Adobe Systems Incorporated, 345 Park Avenue, San Jose, CA 95110-2704, USA.

Notice to U.S. government end users. The software and documentation are “Commercial Items,” as that term is defined at 48 C.F.R. §2.101, consisting of “Commercial Computer Software” and “Commercial Computer Software Documentation,” as such terms are used in 48 C.F.R. §12.212 or 48 C.F.R. §227.7202, as applicable. Consistent with 48 C.F.R. §12.212 or 48 C.F.R. §§227.7202-1 through 227.7202-4, as applicable, the Commercial Computer Software and Commercial Computer Software Documentation are being licensed to U.S. Government end users (a) only as Commercial items and (b) with only those rights as are granted to all other end users pursuant to the terms and conditions herein. Unpublished-rights reserved under the copyright laws of the United States. For U.S. Government End Users, Adobe agrees to comply with all applicable equal opportunity laws including, if appropriate, the provisions of Executive Order 11246, as amended, Section 402 of the Vietnam Era Veterans Readjustment Assistance Act of 1974 (38 USC 4212), and Section 503 of the Rehabilitation Act of 1973, as amended, and the regulations at 41 CFR Parts 60-1 through 60-60, 60-250 ,and 60-741. The affirmative action clause and regulations contained in the preceding sentence shall be incorporated by reference.

® Flash® Builder™ 4.

http://www.apache.org/).

http://www.opensymphony.com/)

Dernière mise à jour le 29/4/2010

Sommaire

Chapitre 1 : A propos de Flash Builder

Possibilités d’utilisation de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Versions de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

Programmes d’installation Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

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

Chapitre 2 : Workbench Flash Builder

Notions de base du workbench Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Navigation et personnalisation du workbench Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Chapitre 3 : Utilisation des projets

A propos des projets Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

Création de projets Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

Gestion des projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

Exportation et importation de projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

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

Gestion des ressources du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Projets ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Projets de bibliothèque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Génération de projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Génération par ligne de commande de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

Exécution des applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

Création de modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

iii

Chapitre 4 : Modification du code dans Flash Builder

A propos de la modification du code dans Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

Aide au codage dans Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

Navigation et organisation du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Formatage et modification du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

Recherche de références et restructuration de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

Icônes représentant les éléments de langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

A propos des marqueurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

A propos de la vérification de la syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

Raccourcis clavier d’édition de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

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

Chapitre 5 : Création de composants MXML personnalisés

A propos des composants personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

Création de composants MXML avec Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

Création de composants visuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

Définition de commentaires ASDoc pour les composants personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

Modification et distribution des composants MXML personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Sommaire

Chapitre 6 : Développement d’applications AIR avec Flash Builder

Création de projets AIR avec Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

Conversion de projets Flex en projets Adobe AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

Débogage des applications AIR avec Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

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

Création d’un projet de bibliothèque AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

Chapitre 7 : Débogage, test et surveillance des applications

Débogage des applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

Environnement de test FlexUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

Surveillance des applications accédant aux services de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

Chapitre 8 : Profilage des applications Flex

A propos du profilage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Fonctionnement du profileur Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

Utilisation du profileur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

A propos des vues du profileur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

A propos de la récupération de place . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

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

A propos des filtres du profileur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

Chapitre 9 : Création d’une interface utilisateur avec Flash Builder

A propos de la structure des interfaces utilisateur dans Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

Ajout et modification des composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

Utilisation visuelle des composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

Utilisation de présentations basées sur des contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

Création de gestionnaires d’événement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

Application de thèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

Application de styles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

Modification de l’interface utilisateur à l’aide des habillages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

Génération de rendus d’élément personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

Actualisation du mode Création pour un rendu correct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

Ajout d’états d’affichage et de transitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

Liaison des contrôles à des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

Ajout de composants de représentation graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

Ajout d’interactivité à l’aide d’effets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

Chapitre 10 : Utilisation de données dans Flash Builder

A propos de l’utilisation des données dans Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

Génération automatique du code Flex Ajax Bridge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

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

Chapitre 11 : Personnalisation de Flash Builder

Préférences Adobe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248

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

Extension de Flash Builder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

Dernière mise à jour le 29/4/2010

Chapitre 1 : A propos de Flash Builder

Adobe® Flash® Builder™ est un environnement de développement intégré permettant la génération d’applications Internet riches (Rich Internet Applications, RIA) multiplateformes. Flash Builder vous permet de générer des applications utilisant la structure Adobe Flex®, MXML, Adobe Flash Player, Adobe AIR®, ActionScript 3.0, Adobe® LiveCycle® Data Services ES et les composants de représentation graphique Adobe® Flex®. 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 Macintosh OS X et est disponible en plusieurs versions. Les options de configuration d’installation vous permettent d’installer Flash Builder en ensemble de plug-ins dans une installation de workbench Eclipse existante ou de créer une installation incluant le workbench Eclipse.

Possibilités d’utilisation de Flash Builder

Flash Builder vous permet de développer des applications dans un environnement IDE complet et de réaliser les tâches suivantes :

• Création de projets Flex compatibles avec toute technologie de serveur back-end, dont Adobe ColdFusion® et

Adobe LiveCycle® Data Services, avec ou sans serveur Flex. Voir « Création de projets Flex » à la page 41.

• Création d’applications accédant aux services de données à distance. Flash Builder fournit des outils et des

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

• Création de projet ActionScript. Voir « Projets ActionScript » à la page 66.

• Rédaction et modification du code source des applications à l’aide d’éditeurs fournissant des fonctions telles que la

restructuration de code, les indicateurs de code, la navigation de code rationnalisée et la vérification automatique des erreurs de syntaxe. Voir « A propos de la modification du code dans Flash Builder » à la page 103.

• Utilisation de l’éditeur MXML en mode Création entre autres pour générer des applications à l’aide des options de

présentation, pour faire glisser des composants vers la zone de création avant de les repositionner et de les redimensionner et pour simplifier l’utilisation par des états d’affichage. Voir « Création d’une interface utilisateur

avec Flash Builder » à la page 188.

• Création de fonctions ActionScript dans le code MXML ou dans des fichiers distincts de fonctions, classes et

interfaces ActionScript.

• Création de composants personnalisés et accès rapide à partir de la vue Composants. Voir « Création de

composants MXML personnalisés » à la page 134.

• Gestion des projets d’application grâce aux nombreuses fonctions fournies par l’environnement IDE Eclipse sous-

jacent. Par exemple, ajout et suppression de projets et de ressources, établissement de liens à des ressources en dehors du projet, etc. Voir « Gestion des projets » à la page 49 et « Création de dossiers et de fichiers dans un

projet » à la page 63.

• Multiples méthodes de génération des applications à l’aide des générateurs intégrés ou création de générateurs

personnalisés à l’aide d’Apache Ant. Voir « Génération de projets » à la page 73.

• Exécution des applications dans un navigateur Web ou dans la version autonome de Flash Player. Création de

configurations de lancement personnalisées pour contrôler l’exécution des applications. Voir « Exécution des

applications » à la page 92 et « Gestion des configurations de lancement » à la page 94.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

A propos de Flash Builder

• Débogage des applications grâce aux outils de débogage intégrés de Flash Builder. Voir « Débogage des

applications » à la page 141.

• Utilisation du Moniteur de réseau pour générer une piste d’audit détaillée de toutes les données transférées entre

l’application Flex locale et le serveur back-end. Voir « Surveillance des applications accédant aux services de

données » à la page 155.

• Publication du code source des applications afin que les utilisateurs et les autres développeurs puissent le visionner.

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

• Création de projets de bibliothèque générant des fichiers de bibliothèque de composants partagés (SWC) pour la

réutilisation et la distribution du code. Voir « Projets de bibliothèque » à la page 69.

• Personnalisation de l’IDE. Par exemple, réorganisation de l’interface afin d’inclure vos outils favoris dans la

présentation spécifique. Voir « Navigation et personnalisation du workbench Flash Builder » à la page 23.

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 reproduisibles pouvant être exécutés à partir de scripts ou directement à l’intérieur ou à l’extérieur 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.

Programmes d’installation Flash Builder

Flash Builder comporte deux programmes d’installation.

Programme d’installation plug-in Ce programme d’installation est destiné aux utilisateurs ayant déjà recours au

workbench Eclipse et souhaitant ajouter les plug-ins Flash Builder à leur ensemble de plug-ins Eclipse. Cela peut être le cas par exemple des développeurs d’applications Java. Etant donné qu’Eclipse est une plateforme extensible et ouverte, des centaines de plug-ins sont disponibles à différentes fins de développement.

Programme d’installation autonome Ce programme d’installation est un package personnalisé de plug-ins Eclipse et

Flash Builder, créé spécialement pour développer des applications qui utilisent la structure Flex et ActionScript 3.0. L’interface utilisateur de l’installation autonome est plus étroitement intégrée que l’installation plug-in. L’installation autonome permet d’éviter en grande partie les confusions auxquelles l’installation plug-in, multi-usage et ouverte, risque de prêter. Elle est idéale pour les nouveaux utilisateurs ainsi que pour ceux qui souhaitent développer uniquement des applications reposant sur la structure Flex et ActionScript 3.0.

Dernière mise à jour le 29/4/2010

Si vous ne savez pas quel programme d’installation utiliser, suivez les recommandations suivantes :

UTILISATION DE FLASH BUILDER 4

A propos de Flash Builder

• Si Eclipse version 3.4.2 (ou ultérieure) est déjà installé, utilisez le programme d’installation plug-in pour ajouter les

fonctionnalités 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 le programme d’installation autonome de Flash Builder. Ce programme d’installation vous permet également d’installer d’autres plug-ins Eclipse afin d’étendre la portée de vos futurs travaux de développement.

Les programmes d’installation plug-in et autonome de Flash Builder fournissent les mêmes fonctionnalités.

Client de l’Aide de la communauté Adobe

Cette version de Flash Builder comporte le client de l’Aide de la communauté Adobe (Adobe Community Help Client, CHC). Le client CHC est une application basée sur AIR qui remplace le moteur d’aide Eclipse pour Flash Builder et constitue la plateforme pour la nouvelle génération d’aide 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

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é regroupe les ressources, dont celles des 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.

Dernière mise à jour le 29/4/2010

Chapitre 2 : Workbench Flash Builder

Notions de base du workbench Flash Builder

Adobe® Flash® Builder™ repose sur Eclipse, un environnement de développement intégré de type « open source ». Il vous permet de développer des applications Flex® et ActionScript® 3.0 à l’aide de puissants outils de codage, de mise en forme visuelle, de création et de débogage.

A propos du workbench

Le workbench Flash Builder est un environnement de développement entièrement intégré conçu pour vous aider à développer des applications pour la structure Adobe Flex. Vous pouvez développer des applications à déployer sur Adobe Flash Player et des applications de bureau à déployer sur Adobe AIR®. Flash Builder repose sur Eclipse, un environnement IDE de type « open source ». Flash Builder est un ensemble de plug-ins Eclipse vous permettant de créer des applications Flex et ActionScript 3.0. La plupart des fonctionnalités de base de l’environnement IDE de Flash Builder provient d’Eclipse. Cela inclut, par exemple, les fonctions de gestion, de recherche et de navigation dans les ressources. Les plug-ins Flash Builder ajoutent les fonctions et fonctionnalités permettant de créer des applications Flex et ActionScript 3.0. Ils modifient également l’interface utilisateur IDE et certaines fonctionnalités pour prendre en charge ces tâches.

Les informations nécessaires à l’utilisation de Flash Builder sont présentées dans la documentation de Flash Builder. A moins d’utiliser d’autres plug-ins Eclipse (CVS ou Java, par exemple) avec Flash Builder, ou si vous souhaitez étendre les plug-ins Flash Builder (voir « Extension du workbench Flash Builder » à la page 23), vous n’avez pas à vous soucier de l’infrastructure Eclipse sous-jacente.

Workbench Le terme workbench désigne l’environnement de développement Flash Builder. 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. Le workbench constitue le conteneur de tous les outils de développement des applications. Vous pouvez le comparer à Microsoft Visual Studio, qui offre un cadre et les principales fonctionnalités d’une large gamme d’outils de développement.

Perspective Une perspective représente un groupe de vues et d’éditeurs du workbench. Il s’agit essentiellement d’un

environnement de travail spécial qui vous aide à réaliser un type de tâche spécifique. Par exemple, Flash Builder contient deux perspectives. La perspective Développement Flash sert au développement d’applications et la perspective Débogage Flash au débogage des applications. Flash Builder Premium contient également la perspective Profil Flash.

Si vous utilisez la configuration plug-in de Flash Builder (voir « Programmes d’installation Flash Builder » à la page 2), 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.

Pour plus d’informations sur les perspectives, voir « A propos des perspectives 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). Pour plus d’informations sur la modification du code dans Flash Builder, voir « A propos de la modification du code dans Flash Builder » à la page 103.

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.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Certaines vues prennent en charge les principales fonctionnalités du workbench. Par exemple, la vue Explorateur de packages vous permet de gérer les fichiers et dossiers au sein du workbench et la vue Tâches affiche toutes les tâches automatiquement générées par le workbench ou ajoutées manuellement.

Le terme vue est synonyme de panneau, ce dernier étant utilisé dans les versions précédentes de Flex 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. Pour plus d’informations, voir « Gestion des projets » à la page 49.

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. Pour plus d’informations, voir « Création de dossiers et de fichiers dans un projet » à la page 63.

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. Vous pouvez créer trois types de projet dans Flash Builder : les projets Flex, les projets ActionScript et les projets de bibliothèque. Pour plus d’informations, voir « Utilisation des projets » à la page 35.

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. Pour plus d’informations, voir « Exécution des applications » à la page 92.

A propos des éditeurs Flash Builder

Flash Builder contient des éditeurs vous permettant d’éditer du code MXML, ActionScript 3.0 et CSS. Les éditeurs constituent la pierre angulaire du workbench et des vues. Les perspectives dans lesquelles ils figurent prennent en charge leurs fonctionnalités.

Les éditeurs sont associés à des types de ressource. Ainsi, lorsque vous ouvrez des ressources dans le workbench, l’éditeur correspondant s’affiche. Le workbench représente un environnement orienté document (et orienté projet) destiné au développement d’applications.

Le développement d’applications Flex dans Flash Builder repose sur l’utilisation des éditeurs MXML, ActionScript 3.0 et CSS. Chaque éditeur intègre les fonctionnalités nécessaires au type de ressource donné. Flash Builder contient les éditeurs suivants.

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 présentation et la conception visuelles 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. Pour plus d’informations, voir « A propos de la modification du code dans Flash Builder » à la page 103.

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

que vous puissiez incorporer des fonctions ActionScript dans un fichier MXML à l’aide de la balise classes sont généralement définies dans des fichiers ActionScript, puis importées dans des fichiers MXML. Cette méthode vous permet de définir la plupart de vos applications Flex 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 « Utilisation visuelle des

composants » à la page 196 et Using Styles and Themes.

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

<fx:Script>, les

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Indicateurs de code

Les éditeurs contiennent de nombreuses fonctionnalités qui simplifient et rationalisent le développement de code. Ils proposent en particulier l’option Assistant de contenu, qui affiche des indicateurs de code et du contenu ASDoc lorsque vous saisissez du code MXML, ActionScript et CSS. Le contenu ASDoc s’affiche également lorsque vous passez le curseur de la souris sur une classe de l’éditeur.

Les indicateurs de code apparaissent automatiquement lorsque vous saisissez du code (vous pouvez également afficher les indicateurs de code en appuyant sur Ctrl+Espace). L’exemple suivant illustre les indicateurs de code dans l’éditeur MXML :

Les indicateurs de code apparaissent lorsque vous commencez à saisir une expression de code reconnue par Flex ou le langage (MXML, ActionScript et CSS). Par exemple, si vous entrez le nom d’un composant, une liste de toutes les propriétés de ce composant apparaît.

Les indicateurs de code ActionScript sont également pris en charge. Les indicateurs de code ActionScript s’affichent dans les balises

<fx:Script> incorporées dans un document MXML et dans des fichiers ActionScript autonomes.

L’Assistant de contenu affiche des indicateurs de code pour tous les éléments de langage ActionScript : interfaces, classes, variables, fonctions, types de renvoi, etc. L’assistant de contenu affiche également le contenu ASDoc pour les classes et interfaces ActionScript.

Il propose également des indicateurs de code pour les composants MXML personnalisés ou les classes ActionScript que vous créez vous-même. Si vous définissez par exemple un composant MXML personnalisé et l’ajoutez à votre projet, les indicateurs de code apparaissent lorsque vous référencez le composant dans le fichier d’application MXML.

Pour plus d’informations, voir « A propos de l’assistant de contenu » à la page 106.

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

Flash Builder permet la génération automatique de code de gestionnaires d’événement afin de simplifier l’association d’événements aux composants de votre application. En mode Création, sélectionnez un composant. Dans la catégorie Evénements de la vue Propriétés, cliquez ensuite sur le bouton Générer un gestionnaire d’événement d’un événement répertorié. L’éditeur affiche le mode Source et génère un gestionnaire d’événement dans la section Script du code source. L’éditeur place également une propriété d’événement dans la balise de composant qui référence le gestionnaire d’événement généré.

Vous pouvez également générer des gestionnaires d’événement en mode Source en faisant appel à l’assistant de contenu.

Dernière mise à jour le 29/4/2010

Pour plus d’informations, voir « Création de gestionnaires d’événement » à la page 208 et « Création de gestionnaires

d’événement pour les composants » à la page 110.

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Navigation par code

La navigation par code simplifie la saisie du code, en particulier avec les projets de grande taille comportant de nombreuses ressources. 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.

D’autres fonctionnalités de navigation par code incluent la réduction de code qui vous permet de réduire et de développer des instructions de code à plusieurs lignes. Une autre fonctionnalité est la vue Structure, qui offre une présentation hiérarchique et vous permet de parcourir tous les éléments de l’interface utilisateur et de code d’un fichier. Pour plus d’informations, voir « Navigation et organisation du code » à la page 111.

Formatage de 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).

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 plus d’informations, voir « Formatage et modification du code » à la page 116.

Recherche de références et restructuration du code

Flash Builder peut rechercher toutes les références et les déclarations correspondant aux identifiants d’un fichier, d’un projet ou d’un espace de travail donné. La recherche porte également sur les éléments reliés à partir de fichiers SWC ainsi que les entrées des chemins de bibliothèque (classes, interfaces, fonctions, variables et quelques métadonnées, par exemple). La restructuration vous permet de renommer les identificateurs de votre code tout en mettant à jour toutes les références correspondantes dans la totalité de la base de code. Pour plus d’informations, voir « Recherche de

références et restructuration de code » à la page 118.

A propos des perspectives 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. Flash Builder contient deux perspectives : Débogage Flash et Développement Flash. Flash Builder Premium contient une perspective supplémentaire, Profil Flash.

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. Vous pouvez changer manuellement de perspective en sélectionnant Fenêtre > Perspective dans le menu principal (Fenêtre > Ouvrir la perspective dans la version plug-in). Vous pouvez également utiliser la barre des perspectives, située dans la barre d’outils principale du workbench.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Si vous utilisez la configuration plug-in de Flash Builder et que vous avez installé d’autres plug-ins Eclipse, de nombreuses autres perspectives peuvent s’afficher. Chaque plug-in Eclipse propose des perspectives prédéfinies, mais vous pouvez les personnaliser à votre guise ou créer vos propres perspectives. La personnalisation ou la création d’une perspective requiert la sélection, le placement et le redimensionnement des éditeurs et des vues nécessaires à la réalisation de vos tâches de développement. Pour plus d’informations sur l’utilisation et la personnalisation des perspectives, voir « Utilisation des perspectives » à la page 23.

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 :

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 et est entourée des vues correspondantes. Les perspectives prédéfinissent la présentation de tous les éléments qu’elles contiennent. Vous pouvez toutefois les réorganiser comme vous le souhaitez. Pour plus d’informations, voir « Navigation et personnalisation du workbench Flash Builder » à la page 23.

En mode Source (édition de code), la perspective Développement contient les éléments suivants.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Editeurs Flash Builder

La zone de l’éditeur affiche tous les documents ouverts. 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.

L’éditeur MXML comporte deux modes (Source et Création). Le passage de l’un à l’autre adapte la perspective Développement en fonction des tâches qui y seront effectuées.

L’éditeur ActionScript est un éditeur à fonction unique permettant la création de fichiers ActionScript.

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).

Pour plus d’informations sur l’utilisation de l’éditeur MXML, voir « A propos de la modification du code dans Flash

Builder » à la page 103 et « Utilisation visuelle des composants » à la page 196.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

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.

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

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 111.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

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. Lorsque vous déboguez vos applications, les erreurs, avertissements et autres informations apparaissent dans la vue Erreurs.

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 « A propos des marqueurs » à la page 122. Pour une présentation des vues optionnelles disponibles dans Flash Builder, voir « Autres vues utiles du

workbench » à la page 20.

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 « Aide au codage dans Flash Builder » à la page 105.

Vue Données/Services

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

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.

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 accédant aux services de données » à la page 155.

Perspective Développement Flash en mode Création

La présentation et la création visuelles des applications ont lieu en mode Création de l’éditeur MXML. Ce mode 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. Il s’agit des vues Composants, Propriétés, Aspect et Etats. 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 Flex dans Flash Builder, voir « Création d’une interface utilisateur avec

Flash Builder » à la page 188.

Remarque : le mode Création n’est pas disponible avec les projets ActionScript. Pour prévisualiser l’interface utilisateur des applications ActionScript, vous devez les créer et les exécuter. Pour plus d’informations sur l’utilisation d’ActionScript, voir « Projets ActionScript » à la page 66 et « Exécution des applications » à la page 90.

En mode Création, la perspective Développement contient l’éditeur MXML et les vues Composants, Etats, Propriétés, Aspect et Structure.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Editeur MXML

Le mode Création MXML vous permet d’interagir visuellement avec les applications. Vous pouvez par exemple faire glisser des composants vers la zone de création, sélectionner et redimensionner des composants et ainsi de suite. Toujours en mode Création, vous pouvez développer l’éditeur MXML de manière telle à pouvoir visualiser et sélectionner chaque composant individuellement. Les modes Panoramique et Zoom permettent en outre d’obtenir une vue plus détaillée des éléments, option utile notamment en présence de composants conteneur incorporés. Pour plus d’informations sur l’utilisation du mode Création, voir « Création d’une interface utilisateur avec Flash Builder » à la page 188.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

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 « Ajout et modification des composants » à la page 191.

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 227.

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 29/4/2010

Panneau Aspect

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

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

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 214.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench 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 201.

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 « Examen de la structure du code

MXML » à la page 204.

Perspective Débogage Flash

La perspective Débogage Flash contient les outils nécessaires au débogage de vos applications. Tout comme la perspective Développement, l’éditeur en est le principal outil. Pour le débogage des applications, l’éditeur, associé aux outils correspondants, recherche et met en surbrillance les lignes de code qui doivent être corrigées avant que vous puissiez poursuivre le test de l’application.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Vous pouvez par exemple définir des points d’arrêt dans le code pour interrompre l’exécution et examiner les valeurs des variables et d’autres informations qui précèdent ce point. Vous pouvez également passer au point d’arrêt suivant ou à l’étape suivante d’un appel de fonction pour visualiser les changements de valeur des variables.

La perspective Débogage apparaît automatiquement lorsque le premier point d’arrêt est atteint. Vous pouvez également passer manuellement à la perspective Débogage en la sélectionnant dans la barre des perspectives située à l’extrémité droite de la barre d’outils principale du workbench.

La perspective Débogage contient les vues Débogage, Points d’arrêt, Console, Variables et Expressions.

Vue Débogage

La vue Débogage (dans d’autres débogueurs, cette option porte le nom pile des appels) affiche le frame de pile du thread suspendu de l’application que vous déboguez. Utilisez la vue Débogage pour gérer le processus de débogage. Cette vue vous permet par exemple de reprendre ou d’interrompre le thread ou une étape dans les instructions de code.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Pour plus d’informations sur l’utilisation de la vue Débogage, voir « Gestion de la session de débogage dans la vue

Débogage » à la page 144.

Les applications créées avec Flex ne comportent qu’un seul thread (ce qui n’est pas le cas de Java, par exemple). Vous ne pouvez déboguer qu’une seule application à la fois. Au cours du débogage d’une application, vous ne pouvez donc afficher les processus et la vue Débogage que d’un seul thread d’exécution.

La vue Débogage affiche la liste des fonctions appelées jusqu’à ce point, dans l’ordre de leur appel. Par exemple, la première fonction appelée apparaît en bas de la liste. Vous pouvez double-cliquer sur une fonction pour la déplacer dans le script ; Flash Builder met à jour les informations de la vue Variables conformément au nouvel emplacement de la fonction dans le script.

Vue Points d’arrêt

La vue Points d’arrêt répertorie tous les points d’arrêt définis dans le projet. Double-cliquez sur un point d’arrêt pour afficher son emplacement dans l’éditeur. Vous pouvez également désactiver, ignorer et supprimer des points d’arrêt.

Pour plus d’informations, voir « Gestion des points d’arrêt dans la vue Points d’arrêt » à la page 143.

Vue Console

La vue Console affiche le résultat des instructions trace placées dans le code ActionScript ainsi que les informations provenant du débogueur lui-même (statut, avertissements et erreurs).

Pour plus d’informations, voir « Utilisation de la vue Console » à la page 145.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Vue Variables

La vue Variables affiche des informations sur les variables dans un cadre de pile sélectionné. Vous pouvez sélectionner les variables à surveiller (dans la vue Expressions) et modifier leurs valeurs dans la session de débogage. Lors de la session de débogage, vous pouvez afficher les modifications effectuées dans le fichier SWF en cours d’exécution et tester des solutions pour résoudre le problème.

Pour plus d’informations, voir « Gestion des variables dans la vue Variables » à la page 145.

Vue Expressions

La vue Expressions permet de surveiller un ensemble de variables critiques. Vous pouvez choisir les variables que vous jugez critiques dans la vue Variables et les ajouter à la vue Expressions afin de les surveiller. Vous pouvez également ajouter et évaluer des expressions de contrôle.

Lorsque vous déboguez l’application, vous pouvez surveiller les variables et, si nécessaire, modifier les valeurs. Vous pouvez ajouter et supprimer des variables dans la vue Expressions. Les expressions de contrôle sont des expressions de code évaluées à chaque interruption du débogage. Pour plus d’informations, voir « Utilisation de la vue Expressions » à la page 146.

Pour plus d’informations sur le débogage des applications Flex et ActionScript, voir « Débogage des applications » à la page 141.

Perspective Profil Flash

Flash Builder Premium propose une perspective supplémentaire. Le profileur Adobe Flex permet d’identifier les problèmes de performance et les fuites de mémoire des applications. La perspective Profil affiche plusieurs panneaux (ou vues) présentant les données de profilage sous différentes formes. Lorsque vous interagissez avec l’application, le profileur enregistre les données concernant le statut de l’application, notamment le nombre d’objets, leur taille, le nombre d’appels de la méthode et le temps consacré à ces appels. Pour plus d’informations sur le profileur, voir « A

propos du profilage » à la page 159.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Autres vues utiles du workbench

Outre les éditeurs et les vues associés aux perspectives par défaut de Flash Builder (développement, débogage et profilage), le workbench contient d’autres vues qui simplifient le processus de développement d’une application.

Vous pouvez accéder aux vues qui n’apparaissent pas déjà dans une perspective et les ajouter au workbench en sélectionnant Fenêtre > Autres vues > Généralités (Fenêtre > Afficher la vue > Autre dans la version plug-in). 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 plus d’informations sur l’utilisation des vues, voir « Utilisation des éditeurs et des vues » à la page 25.

Certaines vues du workbench en particulier vous seront très précieuses lors du développement d’applications dans Flash Builder. Il s’agit des vues Tâches, Signets et Recherche.

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 de garder la trace d’éléments importants. La sélection d’un signet recherche et affiche ce signet dans le workbench.

Pour plus d’informations sur la vue Signets, voir « A propos des marqueurs » à la page 122.

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.

Pour plus d’informations sur la vue Recherche, voir « Recherche dans le workbench » à la page 32.

Menus, barres d’outils et raccourcis du workbench

Toutes les commandes du workbench apparaissent dans le système de menus, les menus contextuels, les barres d’outils et les raccourcis clavier.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Barre d’outils du workbench

Les boutons de la barre d’outils du workbench correspondent aux principales commandes ainsi qu’aux commandes les plus utilisées. Ces commandes sont également disponibles dans les différents menus de Flash Builder.

Les boutons suivants apparaissent dans la barre d’outils du workbench (de gauche à droite).

Nouveau Affiche un menu déroulant contenant tous les types de projet et tous les documents que vous pouvez créer.

Enregistrer Enregistre le document ouvert dans l’éditeur et actuellement sélectionné.

Imprimer la source Imprime le document ouvert dans l’éditeur et actuellement sélectionné.

Générer tout Apparaît lorsque l’option « Générer automatiquement » est désactivée dans le menu Projet.

Exécuter Ouvre le fichier SWF de l’application principale dans le navigateur Web par défaut ou directement dans

l’application Flash Player autonome. Vous pouvez également sélectionner d’autres fichiers d’application dans le projet à partir du menu contextuel associé. Pour plus d’informations, voir « Exécution des applications » à la page 92.

Déboguer Utilise le fichier d’application principal du projet actuel pour ouvrir une session de débogage. Vous pouvez

également sélectionner d’autres fichiers d’application dans le projet à partir du menu contextuel associé. Pour plus d’informations, voir « Lancement d’une session de débogage » à la page 141.

Profiler Crée, gère et exécute des configurations. Pour plus d’informations, voir « A propos du profilage » à la

page 159.

Exporter vers une version validée Lance un assistant qui vous aide à sélectionner l’application pour laquelle vous

souhaitez exporter une version optimisée de qualité finale.

Outils externes Sélectionne une configuration de lancement personnalisée.

Marquer les occurrences Permet de sélectionner et de marquer les occurrences de code en mode Source.

Annotation suivante Permet de sélectionner et de passer aux annotations de code suivantes en mode Source.

Annotation précédente Permet de sélectionner et de passer aux annotations de code précédentes en mode Source.

Emplacement de la dernière édition Renvoie à l’emplacement de la dernière modification apportée à une ressource (la

ligne de code exacte ou, en mode Création, l’élément de l’interface utilisateur auquel vous avez ajouté un contrôle ou pour lequel vous avez défini une propriété, par exemple).

Précédent et Suivant Permettent d’accéder aux documents précédemment sélectionnés. Vous pouvez également

sélectionner les documents actuellement ouverts dans la liste fournie par le menu contextuel associé à ces boutons.

Barre d’outils de l’éditeur MXML

Les boutons de la barre d’outils de l’éditeur MXML permettent de contrôler l’éditeur en modes Source et Création. Pour afficher la barre d’outils, ouvrez un fichier MXML en mode Création.

Les boutons suivants apparaissent dans la barre d’outils de l’éditeur MXML (de gauche à droite).

Source Affiche l’éditeur en mode Source, c’est-à-dire la zone d’édition du code.

Création Affiche l’éditeur en mode Création, c’est-à-dire la zone de présentation et de conception visuelles des

applications Flex.

Dernière mise à jour le 29/4/2010

Actualiser Recharge les éléments visuels (images, fichiers SWF ou fichiers de classes contenant les méthodes API de

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

dessin) définissant l’apparence de l’application. Ces éléments sont désignés collectivement par le terme habillage. Pour plus d’informations, voir Creating Skins.

Etat Liste déroulante répertoriant tous les états d’affichage définis. La sélection d’un état d’affichage entraîne la mise

à jour de l’affichage de la création visuelle. Pour plus d’informations, voir « Ajout d’états d’affichage et de transitions » à la page 227.

Mode Sélection Activé par défaut à l’ouverture d’un fichier, ce mode vous permet de sélectionner, déplacer et

redimensionner des éléments.

Mode Panoramique Permet d’effectuer un panoramique et de parcourir la zone de création. En revanche, ne permet

pas de sélectionner ou de déplacer des éléments.

Mode Zoom Affiche par défaut des valeurs d’agrandissement prédéfinies. Pour effectuer un zoom arrière, appuyez sur

Alt+clic (Opt+clic sous Mac). Pour revenir au mode d’affichage 100%, double-cliquez sur le bouton Mode Zoom.

Agrandissement Liste déroulante affichant des pourcentages d’agrandissement. Cette liste est également disponible

dans le menu Création > Agrandissement. La liste affiche par défaut la valeur 100%.

Barre d’outils de l’éditeur CSS (uniquement Flex 3)

Si vous modifiez un fichier CSS pour un projet d’application basé sur le SDK Flex 3, l’éditeur CSS affiche le mode Création. L’éditeur CSS comporte plusieurs boutons vous permettant de contrôler l’éditeur en modes Source et Création. Pour afficher la barre d’outils de l’éditeur CSS, créez un projet basé sur le SDK Flex 3 et ouvrez un fichier CSS en mode Création.

Les boutons suivants apparaissent dans la barre d’outils CSS (de gauche à droite).

Source Affiche l’éditeur en mode Source, c’est-à-dire la zone d’édition du code.

Création Affiche l’éditeur en mode Création, c’est-à-dire la zone de présentation et de conception visuelles des

applications Flex.

Actualiser Recharge les éléments visuels (images, fichiers SWF ou fichiers de classes contenant les méthodes API de

dessin) définissant l’apparence de l’application. Ces éléments sont désignés collectivement par le terme habillage. Pour plus d’informations, voir Creating Skins..

Style Répertorie les styles contenus dans le fichier CSS.

Nouveau style Affiche la boîte de dialogue Nouveau style permettant de choisir les types de sélecteur et les composants

à appliquer au nouveau style.

Supprimer le style Supprime le style sélectionné du fichier CSS.

Mode Sélection Activé par défaut à l’ouverture d’un fichier. Permet de sélectionner, de déplacer et de redimensionner

des éléments.

Mode Panoramique Permet d’effectuer un panoramique et de parcourir la zone de création. En mode Panoramique,

les éléments ne peuvent être ni sélectionnés ni déplacés.

Mode Zoom Affiche par défaut des valeurs d’agrandissement prédéfinies. Pour effectuer un zoom arrière, appuyez sur

Alt+clic (Opt+clic sous Mac). Pour revenir au mode d’affichage 100%, double-cliquez sur le bouton Mode Zoom.

Dernière mise à jour le 29/4/2010

Agrandissement Affiche les pourcentages d’agrandissement. Cette liste est également disponible dans le menu

Création > Agrandissement. La liste affiche par défaut la valeur 100%.

Arrière-plan Lance un sélecteur de couleurs permettant de sélectionner une couleur d’arrière-plan pour la zone

d’aperçu. Ce changement de couleur ne modifie par le fichier CSS et n’a aucune incidence sur l’application Flex lorsque vous l’exécutez.

Aperçu en tant que Ne s’affiche que lorsque la règle de style n’est associée à aucun composant MXML en particulier.

Editer les grilles d’échelle (pas affiché) Ne s’affiche que lorsque la règle de style utilise des habillages de fichier d’image.

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Utilisation des raccourcis clavier

De nombreuses opérations accessibles à partir du système de menus de Flash Builder sont également disponibles sous forme de raccourcis clavier.

Affichage de la liste de tous les raccourcis clavier de Flash Builder

❖ Sélectionnez Aide > Assistant de touches.

Vous pouvez utiliser l’option Assistant de touches comme référence pour tous les raccourcis clavier Flash Builder, ou exécuter ces commandes directement à partir du panneau Assistant de touches en double-cliquant sur les commandes. Vous pouvez également modifier les raccourcis clavier ou créer vos propres raccourcis. Pour plus d’informations, voir « Modification des raccourcis clavier » à la page 30.

Extension du workbench Flash Builder

Flash Builder se structure autour d’un ensemble de plug-ins Eclipse fournissant les outils nécessaires à la création d’applications Flex et ActionScript 3.0. Cette structure permet aux plug-ins de proposer des points d’extension pouvant être utilisés pour étendre les fonctionnalités et les capacités de l’outil. Pour plus d’informations, voir Référence

d’extensibilité d’Adobe Flash Builder.

Navigation et personnalisation du workbench Flash Builder

Le terme workbench désigne l’environnement de développement Flash Builder. Le workbench contient trois éléments principaux : les perspectives, les éditeurs et les vues. L’utilisation associée de ces trois composants varie en fonction du stade de développement de l’application. Le workbench constitue le conteneur de tous les outils de développement des applications.

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.

Utilisation des perspectives

Les perspectives comportent des combinaisons de vues et d’éditeurs adaptées à l’exécution de certains groupes de tâches. Vous utiliserez ainsi généralement la perspective Débogage Flash pour déboguer une application.

Pour une présentation des perspectives, voir « A propos des perspectives de Flash Builder » à la page 7.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Ouverture et changement de perspectives

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

• Débogage Flash

• Profil Flash

La perspective Profil Flash est disponible dans Flash Builder Premium.

❖ Sélectionnez Fenêtre > Perspective ou choisissez Autre pour afficher toutes les autres perspectives Eclipse (dans la

configuration plug-in de Flash Builder, sélectionnez Fenêtre > Ouvrir la perspective).

Vous pouvez également cliquer sur le bouton Ouvrir la perspective dans l’angle supérieur droit de la fenêtre du workbench afin de sélectionner une perspective dans le menu contextuel.

Pour afficher la liste complète des perspectives, sélectionnez Autre dans le menu contextuel Ouvrir la perspective.

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.

Définition de la perspective par défaut

La perspective par défaut est signalée par le terme par défaut affiché entre parenthèses après le nom de la perspective.

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.

Ouverture des 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 présentation 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.

Vous pouvez également configurer d’autres aspects d’une perspective, notamment les sous-menus Fichier > Nouveau, Fenêtre > Perspective > Autre, Fenêtre > Autres vues ainsi que les jeux d’actions (boutons et options de menu) qui apparaissent dans la barre d’outils et dans les éléments du menu principal (les noms des menus varient légèrement dans la configuration plug-in de Flash Builder).

Création d’une perspective

1 Ouvrez une perspective existante.

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

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Pour plus d’informations, voir « Ouverture des vues » à la page 26 et « Ouverture de fichiers à éditer » à la page 28.

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.

Configuration d’une perspective

1 Ouvrez la perspective à configurer.

2 Sélectionnez Fenêtre > Perspective > Personnaliser la perspective (Fenêtre > Personnaliser la perspective dans la

configuration plug-in de Flash Builder).

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

Flash Builder ajoute le nom de la perspective enregistrée au menu Fenêtre > Perspective (Fenêtre > Ouvrir la perspective dans la configuration plug-in de Flash Builder).

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 rétablir la présentation d’origine d’une perspective que vous avez modifié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 à réinitialiser.

3 Cliquez sur Réinitialiser, puis sur OK.

Utilisation des éditeurs et des vues

La plupart des perspectives du workbench se composent d’un éditeur ainsi que d’une ou de plusieurs vues. Un éditeur est un composant visuel du workbench, généralement utilisé pour éditer ou explorer une ressource. Les vues sont également des composants visuels de l’espace de travail. Elles prennent en charge les éditeurs, offrent des alternatives de présentation des éléments sélectionnés dans l’éditeur et permettent de parcourir les informations du workbench.

Pour une présentation des éditeurs et des vues, voir « A propos du workbench » à la page 4.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Ouverture des vues

Les perspectives contiennent des combinaisons prédéfinies de vues et d’éditeurs. Vous pouvez également ouvrir des vues qui ne figurent pas dans la perspective active.

❖

Sélectionnez Fenêtre et choisissez une vue Flash Builder ou choisissez Fenêtre > Autres vues pour choisir d’autres vues du workbench Eclipse (dans la configuration plug-in de Flash Builder, sélectionnez Fenêtre > Affichage d’une vue).

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 24.

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 de vues rapides » à la page 27.

Déplacement et ancrage des 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 vos modifications en sélectionnant Fenêtre > Perspective > Sauvegarder la perspective sous

(Fenêtre > Sauvegarder la perspective sous dans la configuration plug-in de Flash Builder).

Réorganisation des onglets des vues

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.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Création et utilisation de 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.

Création d’une vue rapide

❖ 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.

Restauration d’une vue rapide en vue normale

❖ 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. Vous pouvez par exemple limiter l’affichage aux problèmes consignés par le workbench ou aux tâches que vous avez consignées comme rappels. Vous pouvez filtrer les éléments en fonction de la ressource ou du groupe de ressources auquel ils sont associés, de la chaîne de texte affichée dans le champ Description, de la gravité du problème, de la priorité de la tâche ou du statut de la 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 « Notions de base du workbench Flash Builder » à la page 4.

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).

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

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.

Ouverture de fichiers à éditer

L’ouverture d’un fichier lance un éditeur dans lequel il peut être modifié.

❖ Effectuez l’une des opérations suivantes :

• Dans le menu contextuel du fichier (quelle que soit la vue de navigation dans laquelle il se trouve), sélectionnez

Ouvrir.

• Double-cliquez sur le fichier dans l’une des vues de navigation.

• Double-cliquez sur le signet associé au fichier dans la vue Signets.

• Double-cliquez sur un avertissement d’erreur ou un enregistrement de tâche associé au fichier dans la vue

Erreurs.

Le fichier s’ouvre dans l’éditeur défini par défaut pour ce type de fichier. Pour ouvrir le fichier dans un autre éditeur, sélectionnez Ouvrir avec dans le menu contextuel du fichier. Sélectionnez l’éditeur que vous souhaitez utiliser.

Association d’éditeurs à des types de fichier

Le workbench permet d’associer les éditeurs à 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.

Dernière mise à jour le 29/4/2010

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.

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

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.

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 la case Actualiser automatiquement. Lorsque vous activez cette option, le workbench consigne toutes les modifications externes apportées au fichier. La vitesse de l’opération 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 sera 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 une vue ou un éditeur de manière à occuper entièrement la fenêtre du workbench.

Agrandissement (restauration) d’une vue ou d’un éditeur

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

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

• 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.

Changement d’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.

Personnalisation du workbench

Vous pouvez personnaliser le workbench en fonction de vos besoins. Vous pouvez par exemple définir l’affichage des éléments dans la barre d’outils principale, créer des raccourcis clavier ou modifier les polices et les couleurs de l’interface utilisateur.

Réorganisation de la barre d’outils principale

Flash Builder vous permet de réorganiser les sections de la barre d’outils principale. Les sections de la barre d’outils principale sont séparées par un espace.

1 Vérifiez que la barre d’outils est déverrouillée. Dans le menu contextuel de la barre d’outils, désélectionnez l’option

Verrouiller les barres d’outils.

2 Positionnez le pointeur de la souris sur la ligne verticale qui délimite sur la gauche la section à déplacer.

3 Cliquez sur cette ligne et déplacez la section vers la gauche, la droite, le haut ou le bas. Relâchez le bouton de la souris

pour positionner la section à son nouvel emplacement.

Afin d’éviter tout déplacement non intentionnel des barres d’outils, verrouillez-les de nouveau en activant l’option

correspondante de leur menu contextuel.

Modification des raccourcis clavier

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

2 Dans l’écran Vue de la boîte de dialogue Touches, sélectionnez la commande à modifier.

3 Dans le champ Liaison, entrez le nouveau raccourci clavier à lier à la commande.

4 Dans la liste déroulante Quand, sélectionnez à quel moment le raccourci clavier doit être activé.

5 Cliquez sur Appliquer ou sur OK.

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

Modification des polices et des couleurs

Par défaut, le workbench utilise les polices et les couleurs du système d’exploitation de l’ordinateur. Vous pouvez cependant personnaliser les polices et les couleurs de différentes manières. Le workbench permet de configurer les polices suivantes.

Police de bannière Apparaît dans la barre de titre de nombreux assistants. Par exemple, l’assistant Nouveau projet Flex

utilise la police de la bannière pour le titre supérieur.

Police de boîte de dialogue Apparaît dans les widgets et les boîtes de dialogue.

Dernière mise à jour le 29/4/2010

Police d’en-tête Apparaît dans l’en-tête de section.

Police de texte Apparaît dans les éditeurs de texte.

Police de console CVS Apparaît dans la console CVS.

Police des ressources ignorées Affiche les ressources ignorées par la console CVS.

Police des modifications sortantes Affiche les modifications sortantes dans CVS.

Police de la console (Police du texte, par défaut) Apparaît dans la console Déboguer.

Police du texte des volets Détails (Police du texte, par défaut) Apparaît dans les volets Détails des vues Débogage.

Police de la table de la vue Mémoire (Police du texte, par défaut) Apparaît dans le tableau de la vue Mémoire.

Police de texte de l’éditeur Java (Police du texte, par défaut) Apparaît dans les éditeurs Java.

Police du texte de l’éditeur de fichier de propriétés (Police du texte, par défaut) Apparaît dans les éditeurs de fichier

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

de propriétés.

Police du texte de comparaison (Police du texte, par défaut) Apparaît dans les outils de comparaison textuelle ou de

fusion.

Police du texte de la comparaison Java (Police du texte, par défaut) Apparaît dans les outils de comparaison ou de

fusion Java.

Police du texte de comparaison de fichiers de propriétés Java (Police du texte de l’éditeur de fichier de propriétés, par

défaut) Apparaît dans les outils de comparaison ou de fusion de fichier de propriétés Java.

Police du titre de partie (Police du texte de l’éditeur de fichier de propriétés, par défaut) Apparaît dans les titres des

vues et des éditeurs.

Police du message de la vue (Police du texte de l’éditeur du fichier des propriétés, par défaut) Affiche les messages

dans la barre de titre de la vue (le cas échéant).

Les plug-ins qui utilisent d’autres polices peuvent également comporter des préférences personnalisables. Le plug-in Java Development Tools permet par exemple de définir la police utilisée par l’éditeur Java (dans Préférences, sélectionnez > Général > Apparence > Couleurs et polices > Java > Police de texte de l’éditeur Java).

Certaines zones (l’arborescence de l’Explorateur de packages, par exemple) sont toujours affichées dans la police du système d’exploitation. Pour modifier la police de ces zones, utilisez les outils de configuration fournis par le système d’exploitation (les propriétés d’affichage du Panneau de configuration de Windows, par exemple).

Modification des polices et des couleurs

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

2 Développez les catégories Comparaison de texte, Couleurs et polices de base, CVS, Déboguer ainsi que Dossiers des

éditeurs et des vues pour rechercher et sélectionner la police et les couleurs à modifier.

Remarque : vous pouvez également cliquer sur Utiliser la police du système au lieu de Modifier pour laisser le système d’exploitation choisir une valeur de police appropriée. Sous Windows par exemple, si vous sélectionnez cette option, Flash Builder utilise la police sélectionnée dans les propriétés d’affichage du Panneau de configuration de Windows.

3 Définissez vos préférences en matière de police et de couleur.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Modification des couleurs

Le workbench fait appel à différentes couleurs pour distinguer les éléments, par exemple les textes d’erreur et les liens hypertexte. Il utilise les mêmes couleurs que le système d’exploitation. Pour les modifier, utilisez dans ce cas aussi les outils de configuration fournis par le système d’exploitation (les propriétés d’affichage du Panneau de configuration de Windows, par exemple).

Modification des couleurs

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

2 Développez les catégories Comparaison de texte, Couleurs et polices de base, CVS, Déboguer ainsi que Dossiers des

éditeurs et des vues pour rechercher et sélectionner la couleur à modifier.

3 Cliquez sur la barre de couleurs à droite pour ouvrir le sélecteur de couleurs.

4 Sélectionnez une nouvelle couleur.

Contrôle du clic et du double-clic

Vous pouvez définir la réaction du workbench à un clic ou à un double-clic.

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

2 Dans la section Mode d’ouverture, sélectionnez les options voulues et cliquez sur OK.

Recherche dans le workbench

Flash Builder intègre un outil de recherche qui vous permet de localiser rapidement des ressources. Pour plus d’informations sur la recherche de texte dans un fichier particulier, voir « Recherche et remplacement de texte dans

l’éditeur » à la page 118.

Recherche de fichiers

Flash Builder vous permet d’effectuer des recherches complexes de fichiers.

❖ Dans la version plug-in de Flash Builder, sélectionnez Rechercher > Rechercher ou Rechercher > Fichier.

Dans la version autonome de Flash Builder, sélectionnez Editer > Rechercher dans les fichiers.

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

Recherche de références et de déclarations

Flash Builder présente 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. Pour plus d’informations, voir « Recherche de références et restructuration de code » à la page 118.

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.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

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 > Autres vues > Généralités (Fenêtre > Afficher la vue > Autre dans la configuration plug-in

de Flash Builder).

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

Utilisation des modes Source et Création de l’éditeur

L’éditeur MXML de Flash Builder vous permet d’utiliser les modes Source ou Création. Flash Builder permet également de créer une vue partagée dans laquelle vous pourrez afficher les deux modes simultanément.

Affichage du fichier en mode Création

❖ Cliquez sur Création en haut de la zone de l’éditeur.

Affichage du fichier en mode Source

❖ Cliquez sur Source en haut de la zone de l’éditeur.

Utilisation simultanée des modes Source et Création

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.

Commutation des modes Source et Création

❖ Appuyez sur Ctrl+`(guillemet ouvrant).

Accès aux raccourcis clavier

Les raccourcis clavier disponibles dans Flash Builder dépendent de nombreux facteurs, y compris de la vue ou de l’éditeur sélectionné, de l’ouverture ou non d’une boîte de dialogue, des plug-ins installés et du système d’exploitation. Vous pouvez obtenir à tout moment la liste des raccourcis clavier disponibles à l’aide de la fonction Assistant de touches.

❖ Sélectionnez Aide > Assistant de touches.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Workbench Flash Builder

Définition des préférences du workbench

Vous pouvez définir les préférences de nombreux aspects du workbench. Vous pouvez par exemple configurer Flash Builder de manière telle à ce qu’il vous invite à sélectionner l’espace de travail au démarrage, définir l’éditeur à utiliser à l’ouverture de certains types de ressource et paramétrer différentes options pour l’exécution et le débogage de vos applications.

Vos préférences Flash Builder s’appliquent uniquement à l’espace de travail actuel. Vous pouvez cependant exporter les préférences du workbench et les importer dans un autre espace de travail. L’exportation des préférences est utile si vous gérez plusieurs espaces de travail ou si vous souhaitez partager les préférences du workbench avec d’autres membres de votre équipe de développement.

Vous pouvez également définir des préférences individuelles pour chaque projet d’un espace de travail, par exemple définir des options de compilation ou de débogage distinctes pour chacun de vos projets Flex.

Définition des préférences du workbench Flash Builder

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

2 Développez Général, choisissez l’une des catégories de préférences du workbench et modifiez-la si nécessaire.

3 Cliquez sur OK.

Dernière mise à jour le 29/4/2010

Chapitre 3 : Utilisation des projets

Adobe® Flash® Builder™ vous permet de créer, gérer, assembler et distribuer des projets pour la création d’applications pour le Web et de bureau. 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.

A propos des projets Flash Builder

Flash Builder adopte une approche classique du développement de logiciels : le regroupement des ressources (dossiers et fichiers) qui constituent une application au sein d’un conteneur appelé projet. Un projet 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 façon dont le débogage est géré et les relations avec d’autres projets dans l’espace de travail.

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.

Outre les projets Flex, Flash Builder offre un type de projet de base appelé projet ActionScript. Grâce à un projet ActionScript, vous pouvez coder et déboguer des applications ActionScript qui accèdent directement aux API d’Adobe Flash Player et sont compilées dans des fichiers SWF. Les projets ActionScript ne font pas appel à la structure Flex ni au langage MXML.

Applications déployées dans Flash Player

Faites appel à l’assistant Nouveau projet Flex pour créer des applications pouvant être déployées dans Flash Player. A la création du projet, sélectionnez l’option Application Web (exécutée dans Adobe Flash Player). Ce type d’application est compilé dans des fichiers SWF autonomes. Pour plus d’informations, voir « Utilisation des projets » à la page 35 et « Projets ActionScript » à la page 66.

Applications déployées dans Adobe AIR

Faites appel à l’assistant de création d’un projet Flex pour créer des applications pouvant être déployées dans Adobe® AIR®. Sous Type d’applications, sélectionnez l’option Application de bureau (exécution dans Adobe AIR). Utilisez la fonction Exporter vers une version validée pour générer un package AIR de qualité finale prêt à être installé. Pour plus d’informations, voir « Développement d’applications AIR avec Flash Builder » à la page 137.

Flash Builder vous permet de déboguer, assembler et gérer des projets AIR. Il vous permet également d’exécuter des applications dans AIR.

Adobe AIR Marketplace est un endroit où les développeurs d’AIR publient des applications AIR que les utilisateurs peuvent télécharger. Pour trouver Marketplace, aller à www.adobe.com/go/marketplace. Si vous avez des questions sur Adobe AIR Marketplace, aller à www.adobe.com/go/marketplace_faq.

Projets de bibliothèque Flex

Flash Builder vous permet également de créer des bibliothèques de code personnalisé que vous partagez entre vos applications ou que vous distribuez à 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. Pour plus d’informations, voir « Projets de bibliothèque » à la page 69.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Applications contenues dans les projets

Pour pouvoir commencer à créer une application dans Flash Builder, vous devez d’abord créer un projet. Spécifiez s’il s’agit d’une application Web (exécutée dans Adobe Flash Player) ou d’une application de bureau (exécutée dans Adobe AIR). Lorsque vous créez un projet Flex, un fichier d’application principale est créé. Vous ajoutez ensuite toutes les autres ressources, dont les fichiers d’application MXML, les fichiers de composants MXML personnalisés et les fichiers ActionScript, qui formeront votre application Lorsque vous créez un projet ActionScript, un fichier ActionScript principal est créé. Vous pouvez ensuite construire une application grâce à ActionScript et à l’API de Flash Player. Pour plus d’informations, voir « Création de projets Flex » à la page 41 et « Gestion des projets » à la page 49.

Projets gérés dans les espaces de travail

Les projets sont gérés depuis un espace de travail, c’est-à-dire une zone définie du système de fichiers contenant les ressources (fichiers et dossiers) composant les applications. Vos projets résident par défaut dans l’espace de travail. Vous pouvez toutefois créer des projets en dehors de l’espace de travail. Flash Builder les relie automatiquement à l’espace de travail. Le passage d’un espace de travail à l’autre entraîne le redémarrage de Flash Builder.

Multiplicité des projets dans chaque espace de travail

Vous pouvez ajouter autant de projets que vous le souhaitez à un espace de travail. Tous les projets s’affichent dans l’Explorateur de packages, dans lequel vous pouvez les gérer à votre guise. Vous pouvez ajouter des ressources, classer les projets dans des dossiers et générer des projets dans l’espace de travail. Pour plus d’informations, voir « Gestion des

projets » à la page 49 et « Création de dossiers et de fichiers dans un projet » à la page 63.

Ressources externes liées

Outre les ressources internes des projets, vous pouvez créer des liens avec des ressources situées en dehors d’un projet et d’un espace de travail. Les ressources externes liées apparaissent en tant que partie du projet, mais elles se trouvent en dehors de l’emplacement du projet. Pour plus d’informations, voir « Liaison à des ressources situées en dehors de

l’espace de travail du projet » à la page 64.

Multiplicité des applications dans un projet

Flash Builder vous permet de définir plusieurs fichiers dans votre projet pour former une application. Lorsque vous créez un projet, Flash Builder génère un fichier d’application principale qui sert de point d’accès à l’application. Le compilateur fait appel à ce fichier pour générer le fichier SWF de l’application. Vous pouvez cependant créer des fichiers d’application supplémentaires en fonction de la complexité du projet. Tous les fichiers d’application doivent se trouver dans le dossier src sous le dossier racine du projet. Pour plus d’informations, voir « Gestion des fichiers

d’application du projet » à la page 52.

Prise en charge de plusieurs SDK Flex

Que vous ayez des projets en cours de développement ou que vous deviez gérer une base de code d’un ancien projet, Flash Builder vous permet d’utiliser différentes versions du SDK Flex. Pour spécifier les SDK installés, vous devez configurer l’espace de travail de Flash Builder, qui propose un SDK par défaut pour tous les projets. Une fois un projet configuré, vous pouvez ajouter, supprimer ou modifier les configurations des SDK dans la boîte de dialogue Préférences en sélectionnant Flex > SDK installés. Vous pouvez aussi modifier les configurations des SDK en sélectionnant Projet > Propriétés > Compilateur Flex. Pour plus d’informations, voir « Utilisation de plusieurs SDK

dans Flash Builder » à la page 83.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Générations automatiques de projets

Par défaut, votre projet est automatiquement généré à chaque fois que vous enregistrez des changements dans un fichier. Vous maîtrisez complètement la façon dont vos applications sont générées ainsi que la fréquence à laquelle elles le sont. Si vous n’avez pas de besoins spécifiques en termes de personnalisation de la génération, celle-ci se fait en toute transparence et les fichiers SWF de l’application sont générés automatiquement. Pour plus d’informations, voir « Génération de projets » à la page 73.

Exportation vers une version validée

Une fois que l’application est prête à être déployée, l’assistant Exporter vers une version validée vous permet de créer une version non déboguée de qualité finale de l’application. L’assistant copie les ressources requises dans un dossier bin-release distinct du dossier de la version de débogage. Vous pouvez définir si le code source de l’application doit être ou non inclus. L’application exportée est une version de production optimisée qui peut être affichée par les utilisateurs finaux. Pour les projets Adobe AIR, les applications AIR sont exportées dans un fichier AIR. La fonctionnalité Exporter vers une version validée permet de créer un fichier AIR signé numériquement que les utilisateurs doivent installer avant d’exécuter une application.

Scripts Ant personnalisés

Apache Ant est un outil de génération Java qui permet de créer des scripts personnalisés pour la création d’applications dans Flash Builder. Ant vous permet de modifier et d’étendre le processus de génération standard. Pour plus d’informations, voir « Personnalisation des générations avec Apache Ant » à la page 83.

Génération par ligne de commande

Flash Builder Premium vous permet d’implémenter des générations par ligne de commande. Faites appel aux générations par ligne de commande pour synchroniser les paramètres de génération d’un développeur avec la génération nocturne. Pour plus d’informations, voir « Génération par ligne de commande de Flash Builder » à la page 86.

Types de projets

Flash Builder permet de créer des types de projets dans les configurations suivantes.

Projets Flex

Les options de configuration des projets dépendent de la façon dont l’application accède aux données et de l’installation d’Adobe® LiveCycle® Data Services ES ou d’Adobe BlazeDS. Vous pouvez créer des projets pour des applications Web (exécutées dans Flash Player) ou de bureau (exécutées dans Adobe AIR). Les options sont les suivantes.

Aucun En l’absence de serveur d’applications, cette configuration de base vous permet de spécifier le dossier de sortie

de l’application Flex compilée. Vous pouvez également définir les chemins de génération du nouveau projet.

ASP.NET Si Microsoft Windows et Microsoft Visual Web Developer sont installés, vous pouvez créer des projets qui

font appel à ASP.NET Development Server pour le déploiement. De plus, si vous avez accès à Internet Information Service (IIS), vous pouvez créer des projets avec un dossier de sortie Flex sous IIS.

ColdFusion Cette configuration de projet vous permet de créer des projets utilisant ColdFusion avec LiveCycle Data

Services, BlazeDS ou ColdFusion Flash Remoting. Si aucune de ces options n’est sélectionnée, le dossier de sortie du projet ColdFusion créé sera situé sous la racine Web (ou dossier virtuel). Flash Builder propose des outils pour accéder aux données distantes des sources ColdFusion. Pour plus d’informations, voir Construction d’applications centrées sur les données avec Flash Builder.

Dernière mise à jour le 29/4/2010

J2EE Cette configuration de projet vous permet de créer des projets dont le déploiement est basé sur J2EE. Vous

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

pouvez spécifier si vous souhaitez utiliser le service d’accès aux objets distants et choisir entre LiveCycle Data Services et BlazeDS. En l’absence de sélection d’un service d’accès aux objets distants, un dossier de sortie est créé sous la racine du serveur d’applications Java. Après avoir activé l’option Utiliser le service d’accès aux objets distants, vous pouvez choisir entre LiveCycle Data Services et BlazeDS. En fonction de votre choix, le projet est déployé sur un serveur LiveCycle Data Services ou BlazeDS. Si le plug-in Eclipse Web Tools Project (WTP) est installé, sélectionnez l’option Créer un projet mixte Java/Flex à l’aide de WTP pour créer des projets mixtes Java/Flex avec ou sans service d’accès aux objets distants. Pour les projets compilés localement avec WTP, les projets sont déployés sur votre serveur J2EE.

Vous pouvez utiliser LiveCycle Data Services avec ou sans WTP. Si vous l’utilisez avec WTP, le projet n’est pas déployé sur le serveur LiveCycle Data Services local, mais il est déployé à l’aide des fonctions WTP.

PHP Cette configuration de projet vous permet de créer des projets Flex dotés d’un dossier de sortie Flex sous la racine

Web Apache/IIS (ou dossier virtuel). Flash Builder propose des outils pour accéder aux données distantes des serveurs PHP. Pour plus d’informations, voir Construction d’applications centrées sur les données avec Flash Builder.

Autre Si le serveur d’applications dont vous disposez n’est pas répertorié, cette option permet de spécifier le dossier

de sortie de l’application compilée. Vous pouvez également définir les chemins de génération du nouveau projet.

Services Web et HTTP Pour chaque type d’application, vous pouvez créer des applications pouvant accéder à des

services Web et HTTP. Flash Builder propose des outils pour l’accès aux services Web et HTTP. Pour plus d’informations, voir Construction d’applications centrées sur les données avec Flash Builder.

Projets ActionScript

En s’appuyant sur l’API de Flash plutôt que la structure Flex, les projets ActionScript permettent aux développeurs d’ActionScript d’utiliser Flash Builder pour coder, générer et déboguer les applications basées uniquement sur ActionScript. Ces projets ne faisant pas appel à MXML pour définir une interface utilisateur, vous ne pouvez pas afficher la présentation et la conception de l’application en mode Création. Vous utilisez exclusivement l’éditeur de source et les outils de débogage le cas échéant, puis vous générez le projet dans des fichiers d’application SWF afin de prévisualiser l’application et de la tester dans un navigateur Web ou un Flash Player autonome. Pour plus d’informations sur les projets ActionScript, voir « Projets ActionScript » à la page 66.

Projets de bibliothèque

Les projets de bibliothèque permettent d’assembler et de distribuer les composants et autres ressources. Ils génèrent des fichiers SWC que vous ajoutez à d’autres projets ou que vous distribuez à d’autres développeurs. Pour plus d’informations, voir « Projets de bibliothèque » à la page 69.

Projets Flash Professional

Utilisez les projets Flash Professional pour modifier, générer ou déboguer les fichiers FLA ou XFL créés avec Adobe Flash Professional CS5. Les projets Flash Professional nécessitent l’installation de Flash Professional CS5. Pour plus d’informations, voir « Création de projets Flash Professional » à la page 48.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

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 « Navigation et personnalisation du workbench Flash Builder » à la page 23.

• 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 de Flash Builder, voir « A propos de la modification du code dans Flash Builder » à la page 103 et « Création

d’une interface utilisateur avec Flash Builder » à la page 188.

Vous pouvez ensuite ajouter des projets, fichiers et dossiers et les organiser et les gérer selon vos besoins (voir « Création de dossiers et de fichiers dans un projet » à la page 63).

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

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.

Pour plus d’informations sur l’utilisation de projets dans l’Explorateur de packages, voir « Gestion des projets » à la page 49 et « Création de dossiers et de fichiers dans un projet » à la page 63.

Création de projets et ouverture de ressources

Flash Builder comporte des assistants pour la création de projets Flex, ActionScript et de bibliothèque Flex. Le tableau suivant décrit chacun de ces projets. Pour créer un projet, sélectionnez Fichier > Nouveau.

Type de projet Description

Projet ActionScript Projet ActionScript basé sur l’API Flash, non sur la structure Flex. Les projets ActionScript permettent

Projet Flex Un projet Flex contient un ensemble de propriétés qui contrôlent la façon dont l’application est

Projet de bibliothèque Flex Les projets de bibliothèque Flex permettent d’assembler et de distribuer les composants ainsi que

Projet Flash Professional Utilisez des projets Flash Professional pour accéder aux fichiers FLA ou XFL créés avec Flash

aux développeurs d’ActionScript d’utiliser Flash Builder pour coder, générer et déboguer les applications basées uniquement sur ActionScript. Pour plus d’informations, voir « Création de projets

ActionScript » à la page 67.

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. Il vous permet de créer des applications qui seront exécutées dans Flash Player (applications Web) ou dans Adobe AIR (applications de bureau). Pour plus d’informations, voir « Définition des propriétés des projets Flex » à la page 49.

d’autres ressources. Ils génèrent des fichiers SWC que vous ajoutez à d’autres projets ou que vous distribuez à d’autres développeurs. Pour plus d’informations, voir « Projets de bibliothèque » à la page 69.

Professional CS5. Cette fonctionnalité permet aux développeurs Flash Professional de profiter de l’environnement de modification et de débogage que fournit Flash Builder. Pour accéder aux fonctions de Flash Professional dans Flash Builder, vous devez installer Flash Professional CS5.

Ressources des projets

Les applications Flex et ActionScript prennent en charge plusieurs types de ressources standard (MXML, ActionScript et CSS). Le tableau suivant répertorie les types de ressources que vous pouvez ajouter à vos projets. Pour ajouter ces ressources, sélectionnez Fichier > Nouveau.

Type de ressource Description

Classe ActionScript Fichier de classe ActionScript. Lorsque vous ajoutez ce type de ressource, l’assistant Nouvelle classe

Fichier ActionScript Modèle de fichier de texte pour la création de fonctions ActionScript.

Interface ActionScript Fichier d’interface ActionScript. Lorsque vous ajoutez ce type de ressource, l’assistant Nouvelle

Fichier CSS Modèle de fichier de texte pour la création d’un fichier Cascading Style Sheets.

Fichier Fichier de texte non formaté. Pour plus d’informations, voir « Création de dossiers et de fichiers dans un

Dossier Dossier standard de système de fichiers permettant de classer le contenu des projets. Pour plus

ActionScript vous invite à préciser des éléments de définition de la classe, tels que la super-classe, les interfaces, etc. Pour plus d’informations sur l’utilisation d’ActionScript dans Flash Builder, voir « Création

d’une classe ActionScript » à la page 67.

interface ActionScript vous invite à préciser des éléments de définition de l’interface tels que les interfaces étendues et le package dans lequel elles résident. Pour plus d’informations sur l’utilisation d’ActionScript dans Flash Builder, voir « Création d’une interface ActionScript » à la page 68.

projet » à la page 63.

d’informations, voir « Création de dossiers et de fichiers dans un projet » à la page 63.

Dernière mise à jour le 29/4/2010

Type de ressource Description

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Application MXML Fichier d’application standard dont l’élément MXML racine est la balise <s:Application> (pour les

Composant MXML Fichier de composant standard dont l’élément MXML racine est la balise

Rendu d’élément MXML Les rendus d’élément contrôlent l’aspect d’un élément de données dans un conteneur DataGroup,

Habillage MXML Les classes d’habillage modifient l’aspect des contrôles dans une interface utilisateur. La création, la

Module MXML Ressource pouvant être ajoutée à un projet d’application existant ou créée séparément, mais toujours

Classe de script de tests

Classe de suite de tests

Package Crée un nouveau package pour les fichiers source d’un projet. L’emplacement par défaut est le

Autre Autres types de fichiers enregistrés dans Flash Builder. Sélectionnez Fichier > Nouveau > Autre pour

projets Flex 4). Vous pouvez définir la présentation à utiliser pour l’application. Un projet Flex peut contenir plusieurs fichiers d’application. Pour plus d’informations, voir « Gestion des fichiers

d’application du projet » à la page 52.

permet de spécifier un élément MXML racine alternatif. Pour plus d’informations, voir « Création de

composants MXML avec Flash Builder » à la page 134.

SkinnableDataContainer ou dans une sous-classe de ces conteneurs. L’aspect peut inclure la police, la couleur d’arrière-plan, la bordure et tout autre aspect visuel de l’élément de données. Pour plus d’informations, voir « Génération de rendus d’élément personnalisés » à la page 224.

modification et l’importation d’habillages varient en fonction des composants (Spark ou MX). Pour plus d’informations, voir « Modification de l’interface utilisateur à l’aide des habillages » à la page 218.

associée à une application. Pour plus d’informations, voir « Création de modules dans Flash Builder » à la page 96.

Scripts et suites de tests FlexUnit. Vous pouvez générer et modifier des tests pouvant être répétés et exécutables à partir de scripts ou directement dans Flash Builder. Pour plus d’informations, voir « Environnement de test FlexUnit » à la page 150.

répertoire

ajouter d’autres types de fichiers. Si un plug-in Java est installé dans Flash Builder, vous pouvez par exemple ajouter de nouvelles classes, de nouvelles interfaces et de nouveaux packages Java.

Lorsqu’un type de fichier est enregistré dans Flash Builder, un éditeur correspondant est également disponible dans le workbench. Pour plus d’informations, voir « Association d’éditeurs à des types de

fichier » à la page 28.

Vous pouvez en outre ajouter aux projets des types de fichiers non enregistrés en les important. Pour plus d’informations, voir « Importation de projets » à la page 55.

src du dossier du projet.

<s:Group>. L’assistant vous

Pour plus d’informations sur l’ajout de ressources aux projets, voir « Création de dossiers et de fichiers dans un projet » à la page 63.

Création de projets Flex

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 67. Pour plus d’informations sur la création de projets de bibliothèque, voir « Projets de bibliothèque » à la page 69.

Création d’un projet Flex sans serveur

En l’absence de serveur, cette configuration de base vous permet de spécifier le dossier de sortie des applications compilées. Vous pouvez également, en option, définir les chemins de génération du nouveau projet.

1 Sélectionnez Fichier > Nouveau > Projet Flex.

Dernière mise à jour le 29/4/2010

2 Entrez un nom de projet.

3 Sélectionnez un emplacement pour le projet. L’emplacement par défaut est l’espace de travail actuel. Pour choisir

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

un emplacement de projet différent, désactivez l’option Utiliser l’emplacement par défaut.

4 Choisissez le type d’application (Web ou de bureau).

5 Sélectionnez Aucun comme type de serveurs d’applications.

6 Cliquez sur Terminer ou sur Suivant pour accéder à d’autres options de configuration.

Voir « Options supplémentaires pour la configuration d’un projet » à la page 46.

Création d’un projet Flex avec ASP.NET

Si Microsoft Windows et Microsoft Visual Web Developer sont installés, vous pouvez créer des projets Flex déployés avec ASP.NET. De plus, si vous avez accès à un serveur de développement Internet Information Service (IIS), vous pouvez créer des projets Flex avec un dossier de sortie Flex sous IIS.

1 Sélectionnez Fichier > Nouveau > Projet Flex.

2 Entrez un nom de projet.

3 Spécifiez l’emplacement du projet. L’emplacement par défaut est l’espace de travail actuel. Sous Windows, l’espace

de travail par défaut est C:\Documents and Settings\Développeur FlexAdobe Flash Builder\. Pour choisir un emplacement de projet différent, désactivez l’option Utiliser l’emplacement par défaut.

4 Choisissez le type d’application (Web ou de bureau).

5 Sélectionnez ASP.NET comme type de serveurs d’applications.

6 Cliquez sur Suivant.

7 Sélectionnez le serveur ASP.NET :

• Si vous utilisez un serveur de développement ASP.NET, vous n’avez pas besoin de préciser l’emplacement du

serveur.

• Si vous utilisez IIS, entrez la racine de l’application Web et l’URL de l’application Web.

• Spécifiez le dossier de sortie de l’application Flex.

8 Cliquez sur Terminer ou sur Suivant pour accéder à d’autres options de configuration.

Voir « Options supplémentaires pour la configuration d’un projet » à la page 46.

Création d’un projet Flex avec J2EE

Cette configuration de projet vous permet de créer des projets Flex utilisant un servlet J2EE avec l’option de service d’accès aux objets distants. Si aucune option n’est sélectionnée et qu’un serveur Java est utilisé, un dossier de sortie est créé sous la racine du serveur. Si le plug-in Eclipse Web Tools Project (WTP) est installé, vous pouvez créer des projets mixtes Java et Flex avec ou sans service d’accès aux objets distants.

Remarque : LiveCycle Data Services ES et BlazeDS prennent en charge des versions spécifiques du SDK Flex. Consultez le Tableau de compatibilité LiveCycle Data Services pour découvrir les versions du SDK Flex prises en charge par votre version de LiveCycle DataService ES. Ce tableau de compatibilité répertorie également les versions du SDK Flex prises en charge par BlazeDS.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Vous disposez de deux options de compilation d’un projet Flex utilisant J2EE. L’option recommandée compile l’application localement, puis enregistre les fichiers (notamment le fichier SWF et l’enveloppe HTML) sur le serveur. La seconde option compile le fichier source de l’application directement sur le serveur.

1 Sélectionnez Fichier > Nouveau > Projet Flex.

2 Entrez un nom de projet.

3 Spécifiez l’emplacement du projet. L’emplacement par défaut est l’espace de travail actuel. Pour choisir un

emplacement de projet différent, désactivez l’option Utiliser l’emplacement par défaut.

4 Choisissez le type d’application (Web ou de bureau).

5 Sélectionnez J2EE comme type de serveurs d’applications.

6 Cochez l’option Utiliser le service d’accès aux objets distants. LiveCycle Data Services ES est sélectionné par défaut.

Vous pouvez sélectionner BlazeDS. Si vous avez installé WTP, vous pouvez aussi choisir de créer un projet mixte Java et Flex faisant appel à WTP (le dossier source Java est sélectionné pour vous).

7 Cliquez sur Suivant.

8 Configurez le serveur J2EE.

• Si vous sélectionnez les options Utiliser le service d’accès aux objets distants et LiveCycle Data Services ou

BlazeDS, précisez les paramètres racine :

Dossier racine Serveur Flex (application Web) qui sert votre application (C:\fds2\jrun4\servers\default\flex,

par exemple). Si vous n’utilisez pas l’option de serveur de développement par défaut pour Flex, vous pouvez spécifier un nouvel emplacement pour le dossier racine. Il doit toutefois s’agir d’un dossier valide mappé à l’URL racine spécifiée. Si vous utilisez un serveur distant, précisez son emplacement (monServeur\MesApplications\jrun4\servers\default\flex, par exemple).

URL racine URL racine valide du serveur Flex (application Web) qui sert votre application. Pour LCDS, l’URL

racine par défaut des occurrences du serveur local est http://localhost:8400/lcds/. Si vous utilisez un serveur distant, l’URL peut avoir l’aspect suivant : http://monserveur.com:8400/lcds/.

Racine du contexte La racine du contexte correspond généralement au dernier segment du chemin racine de

l’URL.

• Si vous avez sélectionné l’option Créer un projet mixte Java/Flex à l’aide de WTP (avec ou sans LiveCycle Data

Services) :

• Indiquez le nom des dossiers source et des exécutions cible Java et Flex.

Lorsque vous créez un projet Flex avec LiveCycle Data Services ES, Flash Builder crée un répertoire portant le même nom que le projet ou utilise un répertoire existant portant ce nom. Ce répertoire est un sousrépertoire du dossier racine que vous avez spécifié pour le projet.

• Avec LiveCycle Data Services ES, précisez un fichier flex.war qui se trouve dans le dossier d’installation du

serveur.

Remarque : quelle que soit l’option choisie pour un projet LiveCycle Data Services ES dans Flash Builder, vous devez spécifier un dossier racine LiveCycle Data Services ES et une URL racine. Ces valeurs mappent la racine d’une application Web LiveCycle Data Services ES. Si vous désélectionnez les options, vous devez saisir uniquement la racine Web et l’URL racine.

9 Spécifiez l’emplacement auquel le projet sera compilé.

• Pour les applications compilées localement, Flash Builder crée un dossier de débogage nom_du_projet dans

lequel les fichiers SWF et les enveloppes HTML sont enregistrés.

• Pour les applications compilées sur le serveur, l’emplacement du projet doit se trouver sur le serveur.

Dernière mise à jour le 29/4/2010

10 Cliquez sur Terminer ou sur Suivant pour accéder à d’autres options de configuration.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Voir « Options supplémentaires pour la configuration d’un projet » à la page 46.

Création d’un projet Flex accédant aux services ColdFusion

Pour accéder aux données qui utilisent ColdFusion, vous devez disposer d’Adobe ColdFusion® 8 ou d’Adobe ColdFusion 9. Pour plus d’informations, consulter lapage produit de ColdFusion.

1 Sélectionnez Fichier > Nouveau > Projet Flex.

2 Entrez un nom de projet.

3 Spécifiez l’emplacement du projet.

Vous pouvez également accepter l’emplacement par défaut, qui est l’espace de travail actuel.

4 Spécifiez le type d’application (Web ou de bureau).

5 Pour le type de serveurs d’applications, sélectionnez ColdFusion, puis choisissez l’une des options suivantes.

Utiliser le service d’accès aux objets distants Si vous désactivez l’option Utiliser le service d’accès aux objets

distants, spécifiez la racine Web et l’URL racine à l’étape suivante.

Si vous activez l’option Utiliser le service d’accès aux objets distants, vous pouvez effectuer les choix suivants.

• ColdFusion Flash Remoting

Activez cette option si vous prévoyez d’utiliser les outils de développement centrés sur les données disponibles avec Flash Builder. Cette option s’applique également si vous utilisez Flash Remoting pour invoquer des méthodes dans les composants ColdFusion (CFC). Voir Création d’applications centrées sur les données avec Flash Builder.

• LiveCycle Data Services

Spécifiez LiveCycle Data Services comme type d’application ColdFusion uniquement si votre installation ColdFusion 8 est configurée pour LiveCycle Data Services 2.6.1. Voir Integrating Adobe LiveCycle Data Services

ES 2.6 with Adobe ColdFusion 8.

Généralement, le type de serveurs d’applications pour LiveCycle Data Services n’est pas ColdFusion, mais J2EE. Voir « Création d’un projet Flex avec J2EE » à la page 42.

• BlazeDS

Spécifiez BlazeDS comme type d’application ColdFusion uniquement si votre installation ColdFusion 8 est configurée pour Adobe BlazeDS 3.1. Voir Integrating BlazeDS with a ColdFusion 8 Installation.

Généralement, le type de serveurs d’applications pour BlazeDS n’est pas ColdFusion, mais J2EE. Voir « Création

d’un projet Flex avec J2EE » à la page 42.

6 Cliquez sur Suivant. Spécifiez un emplacement de serveur, une racine Web, une URL racine et une racine du

contexte.

Pour l’accès à un service d’objets distants, vous pouvez définir une configuration ColdFusion autonome ou une configuration ColdFusion déployée sur un serveur J2EE.

• Autonome

Activez l’option Autonome si l’installation ColdFusion utilise la configuration du serveur.

Spécifiez l’emplacement du serveur ColdFusion, de la racine Web et de l’URL racine.

• Déployée sur un serveur J2EE

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Activez cette option si l’installation ColdFusion utilise aussi bien la configuration multiserveurs que la configuration J2EE.

Spécifiez la racine Web, l’URL racine et la racine du contexte. Si vous faites appel à la configuration multiserveurs ColdFusion, vous ne devrez généralement pas spécifier la racine du contexte.

La racine du contexte correspond en règle générale au dernier segment du chemin racine de l’URL lorsque vous déployez ColdFusion en tant qu’application Web dans la configuration J2EE ColdFusion.

Pour spécifier l’emplacement du serveur ou de la racine Web, recherchez un répertoire local ou saisissez le chemin vers un répertoire situé sur un serveur réseau. Vérifiez que le répertoire est partagé et que le compte sous lequel Flash Builder est exécuté possède des droits d’accès en écriture.

Vérifiez que vous avez mappé ou monté un lecteur réseau pour le serveur réseau. Le chemin au serveur réseau est fonction de la plateforme. Par exemple :

(Windows)

\\10.192.18.12\serveur\racine Web

(Windows) Z:\racine Web

(Mac) /Volumes/racine Web

7 Cliquez sur Valider la configuration pour vérifier l’exactitude des paramètres spécifiés.

Si le répertoire de la racine Web n’est pas accessible en écriture, Flash Builder affiche un avertissement.

8 Sélectionnez un dossier de sortie pour l’application compilée.

9 Cliquez sur Terminer ou sur Suivant pour accéder à d’autres options de configuration.

Voir « Options supplémentaires pour la configuration d’un projet » à la page 46.

Création d’un projet Flex pour accéder aux services PHP

L’accès aux données de services PHP présuppose l’existence d’un serveur hébergeant les services. Il peut s’agir d’un serveur local ou d’un serveur appartenant à un réseau local.

1 Sélectionnez Fichier > Nouveau > Projet Flex.

2 Entrez un nom de projet.

3 Sélectionnez un emplacement pour le projet. L’emplacement par défaut est l’espace de travail actuel. Pour choisir

un emplacement de projet différent, désactivez l’option Utiliser l’emplacement par défaut.

4 Choisissez le type d’application (Web ou de bureau).

5 Sélectionnez PHP comme type de serveurs d’applications. Cliquez sur Suivant.

6 Spécifiez la racine Web et l’URL racine pour le service. Cliquez sur Valider la configuration.

La racine Web et l’URL racine spécifiées appartiennent généralement à votre environnement local. Vous pouvez toutefois également accéder à des serveurs réseau. Vérifiez que le répertoire est partagé et que le compte sous lequel Flash Builder est exécuté possède des droits d’accès en écriture.

Vérifiez que vous avez mappé ou monté un lecteur pour le serveur réseau. Spécifiez ensuite le chemin vers le serveur. Ce chemin est fonction de la plateforme. Par exemple :

(Windows)

\\10.192.18.12\serveur\racine Web

(Windows) Z:\racine Web

(Mac) /Volumes/racine Web

Dernière mise à jour le 29/4/2010

7 (Facultatif) Spécifiez le dossier de sortie de l’application.

8 Cliquez sur Terminer ou sur Suivant pour accéder à d’autres options de configuration.

Voir « Options supplémentaires pour la configuration d’un projet » à la page 46.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Options supplémentaires pour la configuration d’un 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.

Voir « Définition d’un dossier de sortie de projet » à la page 79 et « Exécution des applications » à la page 90.

• 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 ou MX uniquement) » à la page 78.

• Liaison de la structure

Par défaut, les classes d’application de la structure Flex 4 utilisent la liaison dynamique. Les options suivantes sont également activées par défaut :

• Vérifier les condensés RSL

• 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

Voir « Liaison de la structure des applications » à la page 78.

• 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.

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.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Modification des options de serveur des projets existants

Vous serez probablement amené dans certains cas à modifier la configuration d’origine du serveur d’un projet. Pour une application Web ou de bureau, accédez à la fenêtre des propriétés du projet concerné.

Sélectionnez l’option Serveur Flex pour ajouter ou modifier les options du serveur du projet.

• Sélectionnez Aucun pour supprimer la configuration serveur d’un projet.

La suppression de la configuration serveur d’un projet conduit également à la suppression de tout fichier SWC ajouté au chemin d’accès à la bibliothèque pour ce type de serveur.

• Sélectionnez un type de serveur à modifier ou ajoutez la configuration serveur d’un projet.

Toutes les options de serveur pour la configuration serveur sélectionnée sont disponibles. Pour en savoir plus sur les paramètres de configuration du serveur, voir « Création de projets Flex » à la page 41.

La modification du type de serveur d’un projet peut provoquer des erreurs dans le code existant reposant sur le type de serveur d’origine. Vous devrez examiner et corriger chaque erreur de code.

Création d’un projet Flex 4 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 fonctions de Flex 4 et de Flash Builder 4 (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 MX uniquement ne met pas à la disposition des applications du projet les composants Spark fournis avec Flex 4.

Vous pouvez convertir un projet Flex 4 en projet MX uniquement. Gardez cependant à l’esprit que Flash Builder ne réécrit pas le code du projet. Vous devrez mettre à jour le code manuellement 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 Entrez un nom de projet.

3 Sélectionnez un emplacement pour le projet. L’emplacement par défaut est l’espace de travail actuel. Pour choisir

un emplacement de projet différent, désactivez l’option Utiliser l’emplacement par défaut.

4 Choisissez le type d’application (Web ou de bureau).

5 Spécifiez un type de serveurs d’applications (ou n’en spécifiez aucun, s’il n’est pas requis). Cliquez sur Suivant.

6 (Facultatif) Spécifiez le dossier de sortie de l’application.

7 Cliquez sur Terminer ou sur Suivant pour accéder à d’autres options de configuration.

Voir « Options supplémentaires pour la configuration d’un projet » à la page 46.

Conversion d’un projet Flex en projet Flex MX uniquement

1 Dans Flash Builder, activez le projet à convertir.

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.

Dernière mise à jour le 29/4/2010

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.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Création de projets Flash Professional

Utilisez des projets Flash Professional pour accéder aux fichiers FLA ou XFL créés avec Flash Professional CS5. Cette fonctionnalité permet aux développeurs Flash Professional de profiter de l’environnement de modification et de débogage que fournit Flash Builder. Pour accéder aux fonctions de Flash Professional dans Flash Builder, vous devez installer Flash Professional CS5.

Vous commencez généralement par créer un projet et des fichiers dans Flash Professional. Vous créez ensuite un projet correspondant dans Flash Builder pour la modification et le débogage des fichiers. Lors de la modification des fichiers dans Flash Builder, vous pouvez définir des points d’arrêt dans les fichiers ActionScript du projet. Les points d’arrêt définis dans des fichiers appartenant au projet Flash Professional sont reconnus par le débogueur Flash Professional lors de l’appel de Déboguer l’animation.

Vous pouvez lancer Flash Professional à partir de Flash Builder pour publier et exécuter les fichiers. Vous pouvez également lancer le débogueur Flash Professional à partir de Flash Builder.

Création d’un projet Flash Professional

1 Sélectionnez Fichier > Nouveau > Projet Flash Professional.

2 Recherchez le fichier FLA ou XFL pour le projet.

Le nom du fichier est utilisé comme nom du projet.

3 Spécifiez l’emplacement du projet.

Vous pouvez utiliser l’emplacement par défaut dans l’espace de travail ou rechercher un nouvel emplacement.

4 Cliquez sur Terminer.

Flash Builder ouvre le nouveau projet dans l’Explorateur de packages. Le dossier contenant le fichier FLA cible est accessible. Le fichier FLA sélectionné devient le fichier cible du projet. Les fichiers ActionScript qui dépendent des fichiers cible peuvent être modifiés.

S’il n’est pas déjà en cours d’exécution, Flash Professional démarre.

Utilisation de projets Flash Professional dans Flash Builder

Vous pouvez appliquer les opérations suivantes aux fichiers source d’un projet Flash Professional :

• Modifier les fichiers ActionScript qui dépendent du fichier FLA cible.

• Déboguer le fichier dans le débogueur Flash Builder ou Flash Professional.

Pour déboguer le fichier dans Flash Builder, sélectionnez Exécuter > Déboguer fichier ou cliquez sur le bouton Déboguer dans la barre d’outils.

Pour déboguer le fichier dans Flash Professional, sélectionnez Exécuter > Déboguer l’animation ou cliquez sur le bouton Déboguer l’animation dans Flash Builder. Les points d’arrêt définis dans Flash Builder sont reconnus par le débogueur Flash Professional.

• Publier le fichier dans Flash Professional CS5.

Sélectionnez Projet > Publier la séquence ou cliquez sur Publier dans le bouton Flash Professional de la barre d’outils.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

• Exécuter le fichier dans Flash Builder ou Flash Professional.

Pour exécuter le fichier dans Flash Builder, sélectionnez Exécuter > Exécuter fichier ou cliquez sur le bouton Exécuter de la barre d’outils.

Pour exécuter le fichier dans Flash Professional, sélectionnez Exécuter > Tester l’animation ou cliquez sur le bouton Tester l’animation de la barre d’outils.

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

1 Sélectionnez Projet > Propriétés du projet > Flash Professional.

2 Sélectionnez Ajouter pour ajouter des fichiers supplémentaires au projet.

Un projet ne peut comporter qu’un seul fichier FLA ou XFL cible comme fichier cible par défaut. Utilisez le bouton Définir par défaut pour spécifier le fichier cible par défaut du projet.

3 Cliquez sur OK.

Gestion des 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.

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.

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 83).

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 occurrence 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 52).

Dernière mise à jour le 29/4/2010

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

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

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 79 et « Génération manuelle de projets » à la page 81).

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 81).

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 de modules dans Flash Builder » à la page 96.

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 41 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. Pour plus d’informations, voir « Application de thèmes » à la page 210.

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 94.

Conversion de projets Flex en projets Adobe AIR

Vous pouvez convertir le type d’applications d’un projet Flex d’application Web (exécutée dans Flash Player) en application de bureau (exécutée dans Adobe AIR). La conversion entraîne les modifications suivantes :

• Un fichier descripteur AIR est créé pour chaque application du projet.

• Les configurations de lancement du projet sont mises à jour de manière telle à être lancées correctement au cours

de l’exécution AIR.

• Les paramètres des enveloppes HTML sont supprimés.

• Les paramètres personnalisés de Flash Player sont supprimés.

• Le chemin d’accès à la bibliothèque est modifié pour inclure le fichier airglobal.swc au lieu du fichier

playerglobal.swc.

Au cours de la conversion, vous pouvez définir pour chaque application du projet si vous souhaitez modifier les balises Application de base en balises WindowedApplication. Si vous décidez de convertir ces balises, cette modification sera la seule à intervenir dans le code d’application au cours de la conversion. Examinez les attributs des balises de base après la conversion pour vérifier que l’application est exécutée correctement dans Adobe AIR.

Modification d’un projet d’application Web en projet d’application de bureau

Remarque : cette procédure ne peut pas être annulée.

1 Sélectionnez le projet que vous souhaitez convertir.

Il doit s’agir d’un projet Flex avec type d’application Web (exécutée dans Flash Player).

2 Dans le menu contextuel du projet, sélectionnez :

Ajouter/Modifier le type de projet > Convertir en projet de bureau (exécution dans Adobe AIR).

Dernière mise à jour le 29/4/2010

3 Dans la boîte de dialogue Convertir en projet Bureau/Adobe AIR, spécifiez si vous souhaitez apporter des

modifications au code :

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

• Convertir les balises Application en WindowedApplication

Les balises Application de toutes les applications existantes du projet sont converties en balises WindowedApplication. Aucune autre modification ne sera apportée au code. Examinez les attributs des balises de base pour vérifier que l’application est exécutée correctement dans Adobe AIR.

Les nouvelles applications créées dans le projet sont des applications de bureau pouvant être exécutées dans Adobe AIR.

• Ne réécrire aucun code

Aucune modification n’est apportée au code. Vous devez éditer les applications dans le projet avant de pouvoir les exécuter dans Adobe AIR.

Les nouvelles applications créées dans le projet sont des applications de bureau pouvant être exécutées dans Adobe AIR.

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 51). 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, pour que le SDK utilisé corresponde à celui du serveur, procédez à l’extraction du SDK du serveur, puis ajoutez-le à Flash Builder en cliquant sur Projet > Propriétés > Compilateur Flex > Configurer les SDK Flex.

Importation de projets utilisant une compilation de serveur distant

L’importation de projets utilisant une compilation de serveur n’est pas prise en charge. Vous pouvez importer un projet spécifiant une compilation de serveur. L’importation comportera toutefois des erreurs qui s’afficheront dans la vue Erreurs. Les erreurs sont accompagnées d’un lien fournissant des informations sur la conversion d’un projet de compilation de serveur en projet de compilation d’outils.

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 52.

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

Dernière mise à jour le 29/4/2010

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

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

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.

Changement du fichier d’application principale

Lorsque vous créez un projet Flex, un fichier d’application principale est créé. Par défaut, il est nommé d’après le projet. Le fichier d’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 d’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 52.

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

d’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 d’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 Flex 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).

Dernière mise à jour le 29/4/2010

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

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Exportation et importation de projets

Flash Builder exporte les projets Flex et les projets de bibliothèques Flex au format FXP. 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 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 253.

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 Flex qui se connectent à des services de données comportent des dossiers vers des fichiers de services déployés. A l’exportation du projet, Flash Builder exporte les liens, mais pas les services déployés. A l’importation, vous devrez déployer les fichiers de services manuellement et mettre à jour les liens, si besoin est.

Pour les projets se connectant aux services via LiveCycle Data Service 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 contenant des liens

• 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

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.

Dernière mise à jour le 29/4/2010

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.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Exportation d’un projet Flex ou d’un projet de bibliothèque Flex au format FXP

Les menus des configurations autonome et plug-in de Flash Builder correspondant à cette procédure diffèrent légèrement.

Certains projets Flex devront faire l’objet d’un traitement spécial à l’importation. Voir « Exportation et importation de

projets » à la page 53.

1 Dans Flash Builder, sélectionnez Fichier > Exporter un projet Flex (FXP).

Dans la version plug-in de Flash Builder, sélectionnez Fichier > Exporter > Flash Builder > 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 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Importation de projets

Flash Builder peut importer des projets Flex, des projets de bibliothèque Flex et des projets ActionScript. Les projets peuvent être importés à partir de dossiers de projet existants ou à partir de fichiers issus d’une préalable exportation à partir de Flash Builder. Vous pouvez importer plusieurs versions d’un même projet Flex ou d’un même projet de bibliothèque Flex. Une fois l’importation de plusieurs versions effectuée, vous pouvez les comparer, puis copier ou fusionner leurs différences.

Projets nécessitant un traitement spécial

Certains projets Flex devront faire l’objet d’un traitement spécial à l’importation. Cela est le cas par exemple lorsque :

• le projet fait référence à une version antérieure du SDK Flex ;

• le projet fait référence à des fichiers de service pour l’accès aux données ;

• la configuration Zend Framework pour l’accès aux services PHP doit être mise à jour ;

• le projet utilise des liens LiveCycle Data Services (LCDS) vers un fichier de modèle de données.

Pour plus d’informations sur les projets nécessitant un traitement spécial, voir « Exportation et importation de

projets » à la page 53.

Prise en charge des projets Catalyst

Flash Builder prend en charge le développement des applications conçues dans Adobe® Flash® Catalyst™. Catalyst exporte un projet au format FXP et des composants au format FXPL. Le fichier FXPL est un package de bibliothèque. Les fichiers FXP et FXPL peuvent être ensuite importés dans Flash Builder à des fins de développement. Pour les fichiers FXP, il en résulte un projet Web Flex exécuté dans Adobe Flash Player. Un fichier FXPL contient un fichier de bibliothèque. Vous pouvez importer des fichiers FXPL sous la forme d’un projet de bibliothèque Flex ou importer le contenu dans un projet Flex existant.

Vous pouvez créer un projet Adobe AIR à partir d’un projet Catalyst. Importez le fichier FXP du projet Catalyst dans Flash Builder. Convertissez le type d’application du projet d’application Web (exécutée dans Flash Player) en application de bureau (exécutée dans Adobe AIR). Voir « Conversion de projets Flex en projets Adobe AIR » à la page 50.

Importation d’un projet Flex ou d’un projet de bibliothèque Flex

Vous pouvez importer un projet à partir d’un fichier FXP exporté ou en accédant au dossier contenant le projet.

Remarque : pour plus d’informations sur l’importation de contenu d’un projet de bibliothèque dans un autre projet Flex, voir « Importation d’un projet FXPL Catalyst » à la page 56. Un projet FXPL est un projet de bibliothèque créé par Adobe Catalyst.

Les menus des configurations autonome et plug-in de Flash Builder correspondant à cette procédure diffèrent légèrement.

1 Dans le menu de Flash Builder, sélectionnez Fichier > Importer un projet FXP.

Dans la version plug-in de Flash Builder, sélectionnez Fichier > Importer > Flash Builder > Projet Flash Builder.

Les fonctions d’importation d’un projet sont également disponibles dans le menu contextuel de l’Explorateur de packages.

2 (Dossier du projet) Si l’importation est effectuée à partir d’un dossier de projet existant, activez l’option Dossier du

projet et recherchez le dossier contenant le projet.

3 (Fichier FXP) Si vous effectuez une importation à partir d’un fichier FXP, sélectionnez Fichier et naviguez jusqu’à

l’emplacement du fichier.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Si le fichier FXP contient plusieurs projets, vous pouvez sélectionnez individuellement les projets à importer.

4 (Projet de bibliothèque ou projet FXPL) Si vous importez un projet de bibliothèque ou un projet FXPL Catalyst,

vous avez la possibilité d’importer le contenu dans un projet existant. Voir « Importation d’un projet FXPL

Catalyst » à la page 56.

5 (Fichier FXP) Si un projet du même nom existe dans l’espace de travail, spécifiez la méthode d’importation.

• Importer en tant que nouveau projet : Flash Builder identifie le projet en ajoutant un chiffre à son nom. Les

versions antérieures du projet sont conservées.

Dans le champ Extraire le nouveau projet vers, spécifiez l’emplacement dans lequel vous souhaitez extraire le fichier. Cet emplacement est généralement un répertoire de l’espace de travail de Flash Builder représentant un dossier du projet. Vous pouvez spécifier un nouveau dossier de projet ou remplacer un projet existant.

• Remplacer un projet existant : sélectionnez le projet que vous souhaitez remplacer. La version antérieure du

projet est définitivement supprimée.

6 (Variables de chemin) Si vous importez un projet définissant des variables de chemin, mettez à jour les variables de

chemin pour le projet.

Les projets compilés pour ColdFusion, PHP, LiveCycle Data Services ou d’autres technologies de serveur font appel aux variables de chemin pour accéder au serveur Web et aux ressources du serveur. D’autres projets peuvent présenter des variables de chemin personnalisées.

Sélectionnez chaque variable de chemin et attribuez-lui une valeur valide.

7 (Références aux polices) Si vous importez un fichier FXP exporté par Catalyst, le projet peut contenir des références

aux polices. Vous avez la possibilité de résoudre ces références.

Voir « Résolution des références aux polices lors de l’importation de projets Catalyst » à la page 57.

8 Cliquez sur Terminer.

9 (Projets pour serveurs PHP) Si vous importez un projet pour serveur d’applications de type PHP, installez ou

mettez à jour l’installation Zend.

La boîte de dialogue Zend vous guide au long du processus.

Remarque : si vous annulez le processus dans la boîte de dialogue Zend, installez ou mettez à jour manuellement Zend Framework. L’accès aux services PHP est impossible tant que Zend Framework n’est pas installé et configuré correctement. Pour plus d’informations sur l’installation, la configuration et le dépannage de l’installation Zend Framework, voir Installation de Zend Framework.

10 (Projets pour serveurs) Déployez des services.

a Placez manuellement des services dans la racine Web du serveur. Utilisez la structure de répertoire utilisée dans

le projet d’origine.

b Dans la vue Données/Services, sélectionnez Actualiser dans le menu contextuel d’un service.

Importation d’un projet FXPL Catalyst

Un projet FXPL Catalyst est un projet de bibliothèque créé par Adobe Catalyst. Lors de l’importation d’un projet FXPL, vous avez la possibilité d’importer le contenu dans un autre projet Flex ou dans un projet de bibliothèque Flex.

Cette fonctionnalité est conçue pour permettre aux développeurs de collaborer avec les concepteurs d’applications Catalyst. Vous pouvez toutefois l’utiliser pour importer le contenu d’un projet de bibliothèque dans un autre projet Flex ou dans un projet de bibliothèque Flex.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Les menus des configurations autonome et plug-in de Flash Builder correspondant à cette procédure diffèrent légèrement. Cette procédure suppose que vous importez un projet de bibliothèque.

1 Dans le menu de Flash Builder, sélectionnez Fichier > Importer un projet FXP.

Dans la version plug-in de Flash Builder, sélectionnez Fichier > Importer > Flash Builder > Projet Flash Builder.

Les fonctions d’importation d’un projet sont également disponibles dans le menu contextuel de l’Explorateur de packages.

2 Activez l’option Fichier et recherchez l’emplacement du fichier.

3 Spécifiez la méthode d’importation.

• Importer nouvelle copie du projet : Flash Builder identifie le projet en ajoutant un chiffre à son nom. Les

versions antérieures du projet sont conservées.

• Importez le contenu dans un projet existant.

Pour Dossier source, accédez au dossier

src d’un projet existant. Pour Package, accédez à un package existant

ou spécifiez un nouveau nom de package pour le contenu.

• Remplacer un projet existant : si un projet du même nom existe dans l’espace de travail, vous pouvez remplacer

le projet existant.

Sélectionnez le projet à remplacer. La version antérieure du projet est définitivement supprimée.

4 Cliquez sur Terminer.

Lors de l’importation de fichiers FXPL, Flash Builder tente de résoudre les références aux polices du fichier FXPL. Voir « Résolution des références aux polices lors de l’importation de projets Catalyst » à la page 57.

Résolution des références aux polices lors de l’importation de projets Catalyst

Lors de l’importation d’un projet FXP créé avec Adobe Catalyst, ce projet peut contenir des références à des polices qui ne sont pas disponibles sur votre système.

L’assistant d’importation permet de corriger les références aux polices à l’aide de CSS. Si vous sélectionnez l’option correspondante, Flash Builder importe la feuille de style Catalyst polices utilisées dans le projet.

Si vous obtenez des erreurs de compilation provenant des polices référencées dans la feuille de style, corrigez les références de la feuille de style avec les polices disponibles sur votre système.

Les projets FXPL Catalyst ne contiennent pas de feuilles de style. Flash Builder tente de corriger les références aux polices lors de l’importation d’un fichier FXPL. S’il ne trouve pas de police correspondante sur le système cible, les références aux polices d’origine sont conservées. Pour les projets FXPL, les références aux polices que Flash Builder ne parvient pas à résoudre sont détectées à l’exécution. Les références aux polices non résolues entraînent une substitution de police ou une erreur d’exécution.

Main.css. Main.css contient les références aux

Remarque : pour les fichiers FXPL, Flash Builder modifie l’attribut de résoudre les références aux polices.

fontFamily dans les fichiers MXML lorsqu’il tente

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Importation d’un projet Flex 3

Vous pouvez importer un projet Flex 3 dans Flash Builder en utilisant le mode de compatibilité Flex 3. Dans ce cas, les espaces de noms et les composants Flex 3 demeureront inchangés. Vous pourrez cependant profiter du compilateur disponible avec Flex 4.

Les documents créés en mode de compatibilité Flex 3 utilisent les composants MX et les espaces de noms suivants :

mx="http://www.adobe.com/2006/mxml"

1 Dans Flash Builder, sélectionnez Fichier > Importer un projet Flex.

2 Recherchez le fichier ZIP du projet Flex 3 précédemment exporté ou le dossier du projet Flex 3.

3 Cliquez sur Terminer.

4 Dans la boîte de dialogue Choisir la version du SDK Flex, vérifiez que le SDK Flex 4 a été activé. Sélectionnez

Utiliser le mode de compatibilité Flex 3.

5 Cliquez sur OK.

Comparaison des modifications apportées à un projet

Si vous importez plusieurs versions d’un projet, vous pouvez comparer, copier ou fusionner les contenus des versions. Vous pouvez uniquement comparer des versions différentes d’un même projet.

1 Dans l’Explorateur de packages, sélectionnez l’un des projets que vous souhaitez comparer.

2 Ouvrez le menu contextuel et sélectionnez Comparer le projet avec la version.

L’affichage de comparaison s’ouvre, vous permettant de comparer le projet à d’autres versions de ce même projet.

3 Sélectionnez la version avec laquelle vous souhaitez effectuer la comparaison. L’éditeur de comparaison Eclipse

s’ouvre.

4 Dans l’éditeur de comparaison, accédez au fichier que vous souhaitez comparer et sélectionnez Afficher la

comparaison du contenu dans le menu contextuel.

L’éditeur de comparaison affiche les deux versions du fichier et en met en évidence les différences.

Vous pouvez utiliser les options de l’éditeur de comparaison pour copier ou fusionner les différences dans le fichier. Pour plus d’informations, voir la documentation Eclipse sur l’éditeur de comparaison.

Importation d’un projet ActionScript

Les projets ActionScript sont exportés au format d’archive ZIP. Utilisez l’assistant d’importation Eclipse pour importer les projets ActionScript.

1 Dans Flash Builder, sélectionnez Fichier > Importer > Autre > Général > Fichier archive.

Vous pouvez également faire appel au menu contextuel de l’Explorateur de packages.

2 Dans la boîte de dialogue d’importation d’un projet Flex, sélectionnez le fichier ZIP à importer.

3 Cliquez sur Terminer.

Importation de projets exportés avec l’assistant d’exportation Eclipse

Un projet exporté à l’aide de l’assistant d’exportation Eclipse devra être importé avec l’assistant d’importation Eclipse. Sélectionnez Fichier > Importer > Général. Recherchez le format correspondant à votre projet.

Pour plus d’informations, voir la documentation Eclipse sur l’importation de projets. Cette documentation est disponible dans l’aide des assistants d’importation et d’exportation Eclipse.

Dernière mise à jour le 29/4/2010

Les services d’un projet créés avec les outils Flash Builder d’accès aux services de données devront être ajoutés manuellement. Copiez les fichiers de serveur dans le dossier services du serveur approprié. Dans la vue Données/Services, utilisez les propriétés du service pour un serveur afin de déterminer l’emplacement du service.

Si vous avez exporté un projet PHP basé sur la structure Zend Framework, cette dernière doit être installée sur le serveur cible. Modifiez le fichier spécifiez le chemin absolu du répertoire d’installation de Zend Framework. Pour plus d’informations sur l’installation, la configuration et le dépannage de l’installation Zend Framework, voir Installation de Zend Framework.

amf-config.ini qui configure la structure Zend Framework. Pour zend_path,

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Importation d’un projet dans plusieurs espaces de travail

Flash Builder importe les projets dans ses espaces de travail. Un projet peut être importé dans plusieurs espaces de travail. Dans ce cas, les fichiers du projet se trouvent dans un seul emplacement sur le disque, mais sont référencés par chaque espace de travail. Les modifications apportées au projet se répercutent dans tous les espaces de travail.

Importation de fichiers source dans un nouveau projet

Vous pouvez créer un projet dans lequel importer les fichiers source et les ressources situés sur votre système de fichiers mais n’appartenant à aucun projet.

1 Dans le menu Flash Builder, sélectionnez Fichier > Nouveau > Projet.

Il peut s’agir d’un projet Flex, d’un projet de bibliothèque Flex ou d’un projet ActionScript.

2 Dans l’assistant Nouveau projet Flex, spécifiez la source et le dossier de sortie.

Remarque : vous pouvez également accepter les emplacements par défaut proposés par l’assistant et y déplacer les fichiers source.

Exportation d’un programme d’installation d’application Adobe AIR

Pour les projets AIR, une génération de production crée un fichier AIR signé numériquement que l’utilisateur doit installer préalablement à l’exécution de l’application. Ce processus s’apparente à la création d’un fichier .exe d’un programme d’installation pour une application native standard. Vous pouvez créer un package intermédiaire non signé que vous pourrez signer ultérieurement avant la publication.

Pour plus d’informations sur l’exportation d’une version de production et d’un programme d’installation AIR, voir « Exportation vers une version validée (application de bureau, exécutée dans Adobe AIR) » à la page 60.

Exportation d’une application vers une version validée

Vous pouvez exporter une version optimisée de qualité finale (fichier SWF ou AIR non débogué) de l’application en utilisant l’assistant Exporter vers une version validée. Les ressources requises sont copiées dans un dossier distinct de celui de la version de débogage. Une fois l’assistant exécuté, vous devrez procéder à des opérations supplémentaires pour déployer l’application sur un serveur.

Exportation vers une version validée (application Web, exécutée dans Adobe Flash Player)

1 Sélectionnez Projet > Exporter vers une version validée pour ouvrir l’assistant correspondant.

2 Sélectionnez le projet et l’application que vous souhaitez exporter.

Dernière mise à jour le 29/4/2010

3 (Facultatif) Sélectionnez Activer l’affichage de la source pour permettre l’accès aux fichiers source à partir de

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

l’application exportée.

Cliquez sur Choisir des fichiers source pour spécifier les fichiers source à inclure. Outre les fichiers source spécifiés, l’assistant génère un fichier archive ZIP contenant les fichiers source.

Important : pour les projets pour serveurs, vous pouvez sélectionner le dossier des services à l’exportation des fichiers source. L’exportation de fichiers implémentant des services a des implications en termes de sécurité. Ces fichiers peuvent donner accès à votre base de données, noms d’utilisateurs et mots de passe inclus. Voir Exportation des fichiers source vers la version validée d’une application.

4 Cliquez sur Terminer.

5 Copiez le dossier contenant la version exportée vers la racine Web du serveur hébergeant l’application.

6 (Projets pour serveurs) Si vous exportez la version d’un projet spécifiant un type de serveurs d’applications,

déployez les services à la racine Web du serveur cible.

Conservez la structure de répertoire utilisé lors du développement.

Cette étape s’applique aux services ColdFusion, PHP, BlazeDS et LCDS. Le type de serveurs d’applications est défini à la création du projet dans Flash Builder.

Pour des fichiers locaux déployés sur le serveur, un fichier de régulation interdomaines est nécessaire pour accéder à ces services. 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. Voir Utilisation des fichiers de régulation interdomaines.

7 (Projets pour serveurs PHP uniquement) Pour les projets PHP, exécutez les étapes supplémentaires suivantes :

a Installez la structure Zend Framework sur le serveur. Voir Installation de Zend Framework.

b Modifiez le fichier amf-config.ini qui se trouve dans le dossier de sortie de la version exportée.

zend_path, spécifiez le chemin absolu du répertoire d’installation de Zend Framework.

Pour

Définissez

Saisissez pour

amf.production sur true.

webroot le chemin absolu vers la racine Web du serveur.

Exportation vers une version validée (application de bureau, exécutée dans Adobe AIR)

Pour les projets AIR, une version de production crée un fichier AIR signé numériquement que l’utilisateur devra installer préalablement à l’exécution de l’application. Ce processus s’apparente à la création d’un fichier .exe de programme d’installation pour une application native standard. Vous pouvez également créer un package intermédiaire non signé que vous pourrez signer ultérieurement avant la publication. Avant d’entamer la procédure d’exportation vers une version validée, vous devez décider de la manière dont vous souhaitez signer numériquement l’application AIR :

• Signer l’application en ayant recours à un certificat numérique VeriSign ou Thawte

• Créer et utiliser un certificat numérique autosigné

• Assembler l’application et la signer ultérieurement

Les certificats numériques délivrés par VeriSign et Thawte confirment votre identité d’éditeur et indiquent qu’aucune modification n’a été apportée au fichier d’installation depuis sa signature. Les certificats numériques autosignés sont utilisés dans le même but, mais se distinguent par le fait qu’ils ne sont pas validés par un tiers.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Vous pouvez également assembler l’application AIR sans signature numérique en créant un fichier AIR intermédiaire (.airi). La validité de ce type de fichier est limitée. Il ne peut en effet pas être installé. Il est utilisé dans les procédures de test (effectuées par les développeurs) et peut être lancé avec l’outil de ligne de commande AIR ADT. La mise à disposition de cette fonctionnalité est liée au fait que dans certains environnements de développement, la signature est prise en charge par un développeur ou une équipe spécifique, garantissant ainsi un niveau de sécurité supérieur.

Exportation d’une application et d’un programme d’installation AIR

1 (Facultatif) Modifiez les paramètres du serveur dans les propriétés du projet.

Une application de bureau exportée peut accéder uniquement aux services utilisés au cours du développement. Si vous souhaitez modifier le serveur pour l’application de bureau exportée, modifiez les paramètres du projet.

2 Sélectionnez Projet > Exporter vers une version validée pour ouvrir l’assistant correspondant.

3 Sélectionnez le projet et l’application que vous souhaitez exporter.

4 (Facultatif) Sélectionnez Activer l’affichage de la source pour permettre l’accès aux fichiers source à partir de

l’application exportée.

5 Sélectionnez l’option Exporter vers un fichier AIR ou l’option Exporter vers le programme d’installation natif.

Cliquez sur Suivant.

L’option Exporter vers un fichier AIR crée un fichier de programme d’installation générique permettant l’installation de l’application sur les plates-formes Windows ou Mac OS X.

L’option Exporter vers le programme d’installation natif crée un programme d’installation pour la plate-forme cible (Windows ou Mac OS X).

6 A la page Signature numérique, procédez comme suit :

Spécifiez le certificat numérique représentant l’identité de l’éditeur de l’application. Pour générer un certificat autosigné, cliquez sur Créer et renseignez les champs requis.

Pour exporter un fichier dont la signature peut être effectuée ultérieurement, exportez un fichier intermédiaire AIRI.

7 Dans la page Contenu du fichier AIR, sélectionnez les fichiers de sortie à inclure dans le fichier AIR ou AIRI.

8 Cliquez sur Terminer.

9 Copiez le projet .air vers le bureau cible.

10 (Projets pour serveurs) Si vous exportez la version d’un projet spécifiant un type de serveurs d’applications,

déployez les services sur le serveur cible.

Cette étape s’applique aux services ColdFusion, PHP, BlazeDS et LCDS. Le type de serveurs d’applications est défini à la création du projet dans Flash Builder.

11 (Projets pour serveurs PHP uniquement) Exécutez les étapes supplémentaires suivantes :

a Installez la structure Zend Framework sur le serveur. Voir Installation de Zend Framework.

b Modifiez le fichier amf-config.ini qui se trouve dans le dossier de sortie de la version exportée.

zend_path, spécifiez le chemin absolu du répertoire d’installation de Zend Framework.

Pour

Dernière mise à jour le 29/4/2010

Définissez amf.production sur true.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Saisissez pour

webroot le chemin absolu vers la racine Web du serveur.

Version déboguée

La version déboguée de l’application contient des informations de débogage. Elle intervient au cours du débogage de l’application. La version validée résultant de l’exportation ne contient aucune information de débogage. La taille de son fichier est donc inférieure à celle du fichier de la version déboguée. Un fichier d’enveloppe HTML contient un lien vers le fichier SWF de l’application. Il intervient dans l’exécution ou le débogage de l’application dans un navigateur Web.

Remarque : les commandes Exécuter et Déboguer lancent la version de développement dans le dossier bin-debug (et non dans le dossier de version validée, bin-release).

Dans une application standard, le dossier de sortie ressemble à l’exemple suivant.

Vous pouvez exécuter ou déboguer vos applications Flex et ActionScript dans un navigateur Web ou dans l’application Flash Player autonome. Pour définir la manière dont les applications sont exécutées ou déboguées, modifiez la configuration de lancement du projet (voir « Exécution des applications » à la page 92). Pour plus d’informations sur l’exécution ou le débogage des applications, voir « Exécution des applications » à la page 90 et « Débogage des

applications » à la page 141.

L’utilisation de LiveCycle Data Services ES conduit à la création d’applications tirant parti des technologies de serveur Flex. Lorsque vous générez des applications LiveCycle Data Services ES, vous pouvez opter entre la compilation locale des fichiers de sortie avec Flash Builder ou la compilation sur le serveur intervenant au moment d’accéder à l’application pour la première fois.

Gestion des ressources du projet

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.

Dernière mise à jour le 29/4/2010

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.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Création de dossiers et de fichiers dans un projet

Vous pouvez ajouter des dossiers et des fichiers à un projet selon vos besoins. Vous pouvez par exemple créer un dossier destiné à stocker tous les modèles de données ou à organiser toutes les ressources qui composent l’aspect visuel de l’application.

Création d’un dossier

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

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 traité comme un nom de package. Vous pouvez y placer des fichiers source qui seront reconnus par le compilateur.

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.

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 64.

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 64). 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.

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 29/4/2010

2 Effectuez l’une des opérations suivantes :

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

• 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 64.

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.

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 63.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Remarque : il est recommandé de lier d’autres projets aux projets de bibliothèque. La liaison des ressources ne doit être utilisée que pour des bibliothèques tierces doté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

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).

Ajout de dossiers de ressources au chemin source du projet

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.

Dernière mise à jour le 29/4/2010

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.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

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 indicateurs 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 indicateurs 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.

Affichage des propriétés des ressources

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.

Projets ActionScript

Flash Builder vous permet de créer des projets ActionScript qui font appel à l’API Flash (et non à la structure Flex). Les outils du workbench de Flash Builder et l’éditeur ActionScript s’associent ainsi pour former un environnement de développement d’applications ActionScript, intégré et riche en fonctionnalités.

Les projets ActionScript ne possèdent pas de représentation visuelle dans Flash Builder. En d’autres termes, il n’existe pas de mode Création pour les applications ActionScript. Vous affichez les applications ActionScript en les compilant dans Flash Builder, puis en les exécutant dans Flash Player. Vous pouvez utiliser tous les outils de débogage.

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 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Création de projets ActionScript

Lorsque vous créez un projet, l’assistant Nouveau projet ActionScript vous guide tout au long des 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 avancées.

1 Sélectionnez Fichier > Nouveau > Projet ActionScript.

2 Saisissez le nom du projet, puis spécifiez les éléments suivants.

Emplacement du projet L’emplacement par défaut est l’espace de travail actuel. Sous Windows, l’emplacement de

l’espace de travail par défaut est C:\Documents and Settings\Développeur FlexAdobe Flash Builder\. Sous Macintosh, l’emplacement de l’espace de travail par défaut est /Users/Développeur FlexAdobe Flash Builder/. Pour choisir un emplacement de projet différent, désactivez l’option Utiliser l’emplacement par défaut.

Version SDK Flex Choisissez la version par défaut ou spécifiez-en une. Vous pouvez aussi cliquer sur le lien

Configurer les SDK Flex pour ajouter, modifier ou supprimer des SDK en accédant à la page principale des Préférences.

3 Cliquez sur Suivant pour définir les options avancées (sinon, cliquez sur Terminer).

Chemin source Précise le chemin de liaison des ressources externes à l’application. En présence d’un dossier de

classes partagées ActionScript par exemple, vous pouvez créer un lien vers ce dossier en l’ajoutant au chemin source.

Chemin d’accès à la bibliothèque Précise le chemin d’accès de liaison des bibliothèques de ressources externes

(fichiers SWC). Par défaut, le chemin d’accès à la bibliothèque des nouveaux projets ActionScript contient les fichiers playerglobal.swc et utilities.swc.

Dossier source principal Précise, par défaut, la racine du projet. Vous pouvez toutefois sélectionner un dossier

différent au sein du projet. Vous pouvez parcourir la structure des dossiers du projet et, le cas échéant, créer un dossier pour la source.

Fichier de l’application principale Précise le nom du fichier ActionScript qui est le fichier de l’application

principale. Par défaut, Flash Builder utilise le nom du projet comme nom de fichier de l’application principale. Vous pouvez le modifier.

Dossier de sortie Précise l’emplacement des fichiers de l’application compilée. Par défaut, il s’agit du dossier bin.

Vous pouvez en sélectionner un autre.

URL du dossier de sortie Précise l’emplacement du serveur des fichiers de l’application compilée. Cette

information est facultative.

4 Une fois les paramètres du projet ActionScript saisis, cliquez sur Terminer.

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.

Dernière mise à jour le 29/4/2010

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 192.

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

Pour plus d’informations, voir Simple Visual Components in ActionScript.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

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.

Génération des fonctions d’accesseur

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).

Flash Builder peut générer des fonctions d’accesseur Get et Set ActionScript pour les variables de classe. 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.

• Préciser si vous voulez générer des fonctions d’accesseur Get et Set.

• 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 sera généré.

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 sera généré, sélectionnez Aperçu avant de cliquer sur OK.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Projets de bibliothèque

Les projets de bibliothèque vous permettent de créer des bibliothèques de code personnalisé que vous pouvez partager entre vos applications ou distribuer à 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. Par exemple, la structure Flex est contenue dans des fichiers SWC. Lorsque vous créez un projet Flex, les fichiers SWC de la structure Flex sont ajoutés au chemin de la bibliothèque du projet. Vous pouvez afficher et modifier le chemin de la bibliothèque dans la page de propriétés du chemin de génération du projet (pour les projets Flex, sélectionnez Projet > Propriétés > Chemin de génération Flex).

Un fichier SWF est archivé dans un fichier SWC contenant des composants, des ressources et un fichier catalog.xml, fichier manifeste des éléments contenus dans le fichier SWF. Le fichier SWF contient généralement un ou plusieurs composants et toute autre ressource requise. L’ajout de la bibliothèque à un projet vous permet d’utiliser ces composants et en active les indicateurs de code.

Les bibliothèques SWC constituent une méthode pratique d’assemblage et de distribution des composants, mais servent également de thèmes, l’aspect visuel des applications Flex. Un fichier de thème SWC contient un fichier CSS ainsi que toutes les ressources graphiques associées. Pour plus d’informations sur la création et l’utilisation des thèmes, voir About themes.

Les bibliothèques sont utiles si vous créez des composants intégralement dans ActionScript et que vous les utilisez en mode Création dans Flash Builder. Les composants ActionScript ne sont pas rendus visuellement en mode Création tant qu’ils ne sont pas compilés dans un fichier SWF. En ajoutant des composants ActionScript dans un projet de bibliothèque, vous créez un fichier SWF qui est contenu dans un fichier SWC. Vous pouvez ajouter la bibliothèque à un chemin d’accès à la bibliothèque d’un projet et les composants ActionScript sont rendus visuellement en mode Création lorsque vous les ajoutez à l’application.

Configuration de bibliothèques pour vos applications

Vous pouvez utiliser les bibliothèques SWC dans vos projets des façons suivantes.

Fusionnées dans l’application Lorsque vous ajoutez un fichier SWC au chemin d’accès à la bibliothèque du projet, les

composants contenus dans la bibliothèque sont disponibles pour être utilisés dans l’application. Lorsque vous générez l’application, seuls les composants de bibliothèque que vous avez utilisés dans les faits sont compilés dans le fichier SWF de l’application. En d’autres termes, tout le code de votre application est fusionné dans un seul fichier SWF. C’est la façon la plus courante et la plus simple d’utiliser les composants de bibliothèques.

Externes à l’application Vous pouvez conserver les composants de bibliothèque séparément du fichier SWF compilé

pour qu’ils ne soient pas fusionnés dans le fichier. Le compilateur résout tout le code contenu dans la bibliothèque utilisé par l’application, mais ne le fusionne pas dans le fichier SWF de l’application. L’avantage de cette méthode est de réduire la taille du fichier SWF de l’application. Les composants contenus dans le fichier SWC sont extraits et chargés dans la mémoire selon les besoins, au moment de l’exécution.

Bibliothèque partagée à l’exécution Dans les projets Flex uniquement, vous pouvez également utiliser des fichiers

SWC en tant que bibliothèque partagée à l’exécution (Runtime Shared Library, RSL), qui s’apparente à une bibliothèque à liaison dynamique sur d’autres plateformes. Vous pouvez utiliser des fichiers SWC en tant que bibliothèque RSL si vous disposez d’un ensemble de composants qui sont utilisés par plusieurs applications.

Le partage de composants entre applications à l’aide de ce type de bibliothèque présente plusieurs avantages. Dans un premier temps, la bibliothèque est chargée en mémoire une fois, placée dans le cache, puis mise à disposition de toutes les applications faisant appel à ces composants. Dans un second temps, les composants se trouvant dans la bibliothèque sont chargés uniquement selon les besoins, ce qui réduit le temps de démarrage de l’application, car la taille de l’application est moindre. Le problème potentiel de cette méthode est que la bibliothèque partagée à l’exécution est

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

chargée en mémoire dans son intégralité, plutôt que les composants individuels que les applications utilisent. Pour plus d’informations sur l’utilisation des fichiers SWC en tant que RSL, voir Using Runtime Shared Libraries.

Création de projets de bibliothèque Flex

Lorsque vous créez un projet de bibliothèque, l’assistant Nouveau projet de bibliothèque Flex vous guide à travers les différentes étapes et vous demande d’indiquer le nom du projet, son emplacement, ainsi que le chemin de génération. Une fois le projet de bibliothèque créé, vous ajoutez des composants, spécifiez les éléments du projet de bibliothèque à inclure dans le fichier SWC, puis générez le projet afin de créer le fichier SWC. La première étape de la création d’un fichier SWC dans Flash Builder est la création d’une projet de bibliothèque Flex.

1 Sélectionnez Fichier > Nouveau > Projet de bibliothèque Flex.

2 Saisissez un nom de projet, puis précisez les éléments suivants.

Emplacement du projet L’emplacement par défaut est l’espace de travail actuel. Sous Windows, l’emplacement de

Version SDK Flex Choisissez la version par défaut ou spécifiez-en une. Vous pouvez aussi cliquer sur le lien

Configurer les SDK Flex pour ajouter, modifier ou supprimer des SDK sur la page principale Préférences.

Inclure les bibliothèques Adobe AIR Sélectionnez cette option si votre bibliothèque doit utiliser des fonctions AIR,

telles que l’accès aux API AIR. Flash Builder change alors le chemin d’accès à la bibliothèque de ce nouveau projet de bibliothèque Flex de manière qu’il contienne les fichiers airglobal.swc et airframework.swc. Les projets Web Flex ne peuvent pas utiliser cette bibliothèque.

Ne sélectionnez pas cette option si vous créez une bibliothèque générique destinée à une utilisation exclusive dans une application Web Flex, ou dans une application Web ou AIR.

3 Cliquez sur Suivant.

4 (Facultatif) Définissez les informations concernant le chemin de génération. Vous pouvez, par exemple, ajouter des

dossiers au chemin source du projet qui contient les composants à inclure dans le fichier SWC. Vous pouvez également ajouter d’autres projets, dossiers ou fichiers SWC de bibliothèque à inclure dans votre projet de bibliothèque. Voir « Utilisation des fichiers SWC dans le cadre des projets » à la page 71.

5 Une fois les paramètres du projet saisis, cliquez sur Terminer.

Ajout de composants à un projet de bibliothèque

Il existe plusieurs façons d’ajouter des composants à un projet de bibliothèque :

• Vous pouvez ajouter des composants, nouveaux ou existants personnalisés, des classes ActionScript et d’autres

ressources au projet.

• Vous pouvez créer des liens avec des composants existant dans d’autres projets de l’espace de travail (voir « Liaison

à des ressources situées en dehors de l’espace de travail du projet » à la page 64).

• Vous pouvez ajouter un dossier lié qui contient des composants au chemin source du projet de bibliothèque (voir

« Ajout de dossiers de ressources au chemin source du projet » à la page 65).

Remarque : tous les composants que vous incluez dans le projet de bibliothèque doivent être associés au projet de bibliothèque (directement ou en tant que ressources liées).

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Sélection d’éléments du projet de bibliothèque à inclure dans le fichier SWC

L’étape suivante de la création d’un fichier SWC de bibliothèque est la sélection des éléments (composants et ressources) à inclure dans le fichier SWC lors de sa création par le compilateur.

1 Sélectionnez Projet > Propriétés > Chemin de génération de bibliothèque Flex.

Les composants que vous avez ajoutés au projet (soit directement soit en les reliant) s’affichent dans l’onglet Classes.

2 Sélectionnez les classes de composants à inclure dans le fichier SWC.

3 (Facultatif) Sous l’onglet Ressources, sélectionnez les ressources à inclure dans le fichier SWC.

4 Une fois que vous avez effectué vos sélections, cliquez sur OK.

Création de projets de bibliothèque

Une fois que vous avez sélectionné les éléments à inclure dans le fichier SWC et si vous avez sélectionné l’option de génération automatique, le fichier SWC est compilé immédiatement et généré dans le dossier de sortie du projet. Si vous générez vos projets manuellement, vous pouvez créer le projet de bibliothèque quand vous le souhaitez en sélectionnant Projet > Générer le projet ou Générer tout.

La création du projet de bibliothèque génère un fichier SWC que vous pouvez partager avec d’autres applications ou utilisateurs.

Un fichier SWC est un fichier archive. Vous pouvez l’ouvrir grâce à n’importe quel utilitaire d’archivage, tel que WinZip. Les fichiers library.swf et catalog.xml sont contenus dans le fichier SWC, ainsi que les fichiers de propriétés et autre ressources incorporées.

Vous pouvez exporter la bibliothèque sous la forme d’un répertoire ouvert plutôt qu’en tant que fichier SWC. Vous exportez généralement une bibliothèque en tant que répertoire ouvert si vous prévoyez de faire appel au fichier library.swf dans le fichier SWC en tant que bibliothèque RSL.

Pour ce faire, vous devez définir les options le nom du répertoire à créer et l’option

directory et output du compilateur. Définissez l’option output comme

directory sur true pour indiquer que vous voulez ouvrir le répertoire et non

un fichier SWC lorsque vous générez la bibliothèque. Pour modifier les options du compilateur, sélectionnez Projet > Propriétés > Compilateur de bibliothèque Flex et ajoutez les options au champ Arguments de compilateur supplémentaires, par exemple :

-directory=true -output=myOpenDir

Flash Builder crée un répertoire dans le projet nommé myOpenDir et y enregistre le contenu du fichier SWC.

Utilisation des fichiers SWC dans le cadre des projets

Pour pouvoir utiliser des fichiers SWC dans vos projets Flex, vous devez les ajouter au chemin d’accès à la bibliothèque du projet. Les fichiers SWC peuvent se trouver dans le projet, dans un projet de bibliothèque Flex, dans un dossier partagé dans l’espace de travail ou dans tout autre emplacement lié au projet (en utilisant un dossier partagé qui a été ajouté au chemin source du projet, par exemple).

Lorsque vous utilisez des fichiers SWC dans des applications, certaines options de configuration déterminent s’ils sont liés de manière statique ou dynamique à l’application, s’ils sont fusionnés dans le fichier SWF de l’application ou s’ils sont externes et si leur accès se fait séparément au moment de l’exécution.

Ajout d’un fichier SWC au chemin d’accès à la bibliothèque

1 Sélectionnez un projet dans l’Explorateur de packages, puis cliquez sur Projet > Propriétés > Chemin de génération

Flex.

Dernière mise à jour le 29/4/2010

2 Cliquez sur l’onglet Chemin d’accès à la bibliothèque.

3 Sélectionnez l’une des options suivantes pour ajouter des fichiers SWC.

Ajouter un projet Ajoute un projet de bibliothèque Flex.

Ajouter un dossier SWC Permet d’ajouter un dossier contenant des fichiers SWC.

Ajouter un fichier SWC Ajoute un fichier SWC compilé.

Ajouter un SDK Flex Permet d’ajouter d’autres SDK Flex. Ce bouton est désactivé si le chemin d’accès à la

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

bibliothèque du projet contient déjà un SDK Flex. Si vous supprimez le SDK Flex existant du chemin d’accès à la bibliothèque, le bouton est activé. Lorsque vous cliquez sur ce bouton, un nœud SDK Flex est ajouté, mais aucune invite ne précise lequel. Pour préciser quel SDK Flex utiliser, sélectionnez Projet > Propriétés > Compilateur Flex.

Saisissez ou recherchez l’emplacement du ficher SWC, du projet ou du dossier, puis sélectionnez-le. Cliquez sur OK.

Le fichier SWC, projet de bibliothèque ou dossier est ajouté au chemin d’accès à la bibliothèque.

Fusion du fichier SWC dans le fichier SWF de l’application au moment de la compilation

1 Sélectionnez un projet dans l’Explorateur de packages, puis cliquez sur Projet > Propriétés > Chemin de génération

Flex.

2 Sous l’onglet Chemin d’accès à la bibliothèque, sélectionnez et développez l’entrée du fichier SWC pour en afficher

les options.

3 Double-cliquez sur l’option Type de lien. La boîte de dialogue Options de l’élément de chemin d’accès à la

bibliothèque apparaît.

4 Sélectionnez l’option Fusionné dans le code, puis cliquez sur OK.

Cette procédure équivaut à utiliser l’option

library-path du compilateur.

Définition du fichier SWC en tant que fichier de bibliothèque externe

1 Sélectionnez un projet dans l’Explorateur de packages, puis cliquez sur Projet > Propriétés > Chemin de génération

Flex.

2 Sous l’onglet Chemin d’accès à la bibliothèque, sélectionnez et développez l’entrée du fichier SWC pour en afficher

les options.

3 Double-cliquez sur l’option Type de lien. La boîte de dialogue Options de l’élément de chemin d’accès à la

bibliothèque apparaît.

4 Sélectionnez l’option Externe, puis cliquez sur OK.

Cette procédure équivaut à utiliser l’option

external-library-path du compilateur.

Utilisation du fichier SWC en tant que bibliothèque RSL

1 Sélectionnez un projet dans l’Explorateur de packages, puis cliquez sur Projet > Propriétés > Chemin de génération

Flex.

2 Sous l’onglet Chemin d’accès à la bibliothèque, sélectionnez et développez l’entrée du fichier SWC pour en afficher

les options.

3 Double-cliquez sur l’option Type de lien. La boîte de dialogue Options de l’élément de chemin d’accès à la

bibliothèque apparaît.

4 Sélectionnez l’option Bibliothèque RSL (Runtime Shared Library).

5 Entrez l’URL où la bibliothèque SWC doit résider lors du déploiement de l’application.

Dernière mise à jour le 29/4/2010

6 (Facultatif) Pour extraire le fichier SWF dans le fichier SWC lorsqu’il se trouve dans l’emplacement de déploiement,

sélectionnez l’option Extraire automatiquement le fichier SWF dans le chemin de déploiement.

7 Cliquez sur OK.

L’utilisation des fichiers SWC en tant que bibliothèque RSL simplifie le processus d’utilisation manuelle de bibliothèques RSL. Pour ce faire, extrayez le fichier SWF du fichier SWC et définissez les valeurs de l’option

shared-library-path du compilateur.

Pour plus d’informations sur l’utilisation des fichiers SWC en tant que bibliothèque RSL, voir Using Runtime Shared Libraries dans Utilisation d’Adobe Flex 4.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

runtime-

Génération de projets

Adobe® Flash® Builder™ génère et exporte automatiquement les projets vers des applications. Cette opération comporte la création de fichiers d’application et de bibliothèque, le placement des fichiers de sortie dans les emplacements appropriés et la signalisation de toute erreur survenue en cours de compilation.

Différentes options permettent d’ajuster les paramètres de génération. Vous pouvez ainsi déterminer la manière dont les projets sont intégrés aux applications. Vous pouvez par exemple définir des préférences pour la génération de projets individuels ou pour l’ensemble des projets de l’espace de travail, modifier le chemin de sortie ou l’ordre de génération et ainsi de suite. Vous pouvez en outre créer des instructions de génération personnalisées à l’aide d’outils tiers tels qu’Apache Ant.

Lorsque les applications sont prêtes à être publiées, vous pouvez en publier l’ensemble du code source ou uniquement certaines parties. A l’instar du code source HTML, le code source de l’application peut être visualisé dans un navigateur Web.

Présentation de la génération et de l’exportation des projets

Un déroulement de travail se compose de la génération de projets Flex et ActionScript, l’option Générer automatiquement étant activée. Au cours du développement, Flash Builder affiche les erreurs et les avertissements dans la vue Erreurs. A l’exécution de l’application, une version de débogage du fichier SWF est placée dans le dossier de sortie (bin) du projet avec les ressources requises et une enveloppe HTML. Cette génération contient des informations de débogage et n’est destinée qu’à l’usage des développeurs. Pour plus d’informations sur l’exportation de projets, voir « Exportation et importation de projets » à la page 53.

Une fois l’application prête à être déployée, l’assistant Exporter vers une version validée vous permet de créer une version optimisée de qualité finale de l’application. Cette opération enregistre le fichier SWF dans le dossier binrelease. Les informations de débogage étant supprimées, la taille du fichier diminue. S’agissant d’une version de production, elle peut être visionnée par les utilisateurs finaux. Pour les projets Adobe AIR, les applications AIR sont exportées dans un fichier AIR. La fonction Exporter vers une version validée permet de créer un fichier AIR signé numériquement que les utilisateurs doivent installer avant d’exécuter une application (à l’instar d’un fichier install.exe).

Les projets Adobe LiveCycle Data Services ES peuvent en revanche être compilés sur le serveur en y accédant. Pour plus d’informations, voir « Gestion des projets » à la page 49.

Aucune exportation n’est requise pour les projets de bibliothèque. Le fichier SWC créé par un projet de bibliothèque Flex se prête à la fois au développement et à la production. Pour plus d’informations, voir « Projets de bibliothèque » à la page 69.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Notions de base sur la génération

MXML et ActionScript 3.0 sont des langages compilés. Contrairement aux langages interprétés (JavaScript, par exemple) immédiatement exécutables par leurs environnements d’exécution, MXML et ActionScript 3.0 doivent être convertis dans un format compilé avant de pouvoir être exécutés dans Flash Player. Ce processus, ainsi que la création des fichiers de sortie correspondants, est désigné par le terme de génération.

Flash Builder génère automatiquement un projet à chaque modification ou enregistrement de l’un de ses fichiers. La possibilité de générer des applications manuellement ne signifie pas qu’il est nécessaire d’y recourir. Toutefois, la compréhension du processus de génération et des fichiers de sortie créés facilitera le diagnostic et la résolution des éventuels problèmes de configuration du projet.

Projets Flex Les fichiers source et les ressources intégrées (les images, par exemple) sont compilés dans un seul et

unique format de sortie désigné par SWF. Les fichiers ayant ce format peuvent être exécutés directement dans l’application Flash Player autonome ou dans un navigateur Web par le biais d’un fichier d’enveloppe HTML, également créé par la génération. Ces fichiers sont créés dans le dossier de sortie du projet (ce dossier, nommé par défaut « bin », peut être renommé).

Projets LiveCycle Data Services ES LiveCycle Data Services ES offre la possibilité de créer des projets qui seront

compilés sur le serveur. Le fichier d’application MXML, auquel il est accédé pour la première fois (par l’intermédiaire d’un navigateur Web), est compilé dans un fichier SWF.

Remarque : les projets LiveCycle Data Services ES peuvent être définis de manière telle à être compilés sur le serveur. Flash Builder les compile néanmoins au fur et à mesure du développement de vos applications, afin de permettre au compilateur de valider la syntaxe du code et d’afficher les messages d’erreur. Ces projets ne disposent pas d’option de dossier de sortie et Flash Builder ne génère aucun fichier de sortie.

Projets ActionScript 3.0 A l’instar des projets Flex, les projets ActionScript 3.0 compilent les fichiers source et les

ressources intégrées dans un fichier SWF.

Projets de bibliothèque Flex Pour les projets de bibliothèque, les fichiers source sont des composants et des ressources

apparentées. Lors de la génération de projets de bibliothèque, un fichier SWC est créé dans le dossier de sortie. Un fichier SWF est archivé dans un fichier SWC contenant des composants, des ressources et le fichier catalog.xml, fichier manifeste des éléments contenus dans le fichier SWF.

Générations automatiques

En configuration autonome, Flash Builder génère vos applications automatiquement. En configuration plug-in, vous devez sélectionner l’option Générer automatiquement. Malgré la possibilité, décrite ci-dessus, de générer des applications manuellement, il ne devrait pas être nécessaire d’y recourir. La désactivation de la génération automatique empêche en outre le compilateur de détecter les erreurs de syntaxe et d’afficher les avertissements et les messages d’erreur au fur et à mesure de la saisie du code. La vue Erreurs ne vous fournira donc aucune information jusqu’à l’achèvement de la compilation du projet. Il est donc conseillé d’activer le mode de génération automatique de Flash Builder.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Options avancées pour la génération de projets

Les options avancées permettent de définir la durée et l’étendue des générations. Vous pouvez par exemple générer un seul projet ou un ensemble de projets dans l’espace de travail ou encore définir un jeu de documents (une collection) de projets à générer. Toutes les commandes de génération se situent dans le menu Projet, ainsi que l’illustre l’exemple suivant. Pour plus d’informations, voir « Options de génération avancées » à la page 81.

Le compilateur Flash Builder est incrémentiel. Il ne génère que les ressources qui ont été ajoutées ou concernées par une mise à jour et ignore toutes les autres, ce qui se traduit par un gain de temps et une utilisation parcimonieuse des ressources du système. Vous disposez toutefois de la possibilité de regénérer l’ensemble des ressources du projet en procédant à une génération nettoyée. Ce type de génération est indiqué lorsque l’application présente un comportement imprévisible au cours des tests effectués. Vous pouvez dans ce cas éliminer toute source potentielle de problèmes en ignorant et regénérant tous les fichiers du projet. Pour plus d’informations, voir « Options de génération

avancées » à la page 81.

En présence de dépendances entre des projets distincts de l’espace de travail, le compilateur détermine automatiquement l’ordre dans lequel les projets ont été générés afin de résoudre correctement les dépendances. Vous pouvez toutefois remplacer l’ordre de génération par défaut en définissant manuellement l’ordre dans lequel les projets de l’espace de travail sont générés. Pour plus d’informations, voir « Génération manuelle de projets » à la page 81.

Vous pouvez en outre modifier le chemin d’accès à la génération, la liste des applications et les paramètres du compilateur pour chaque projet de l’espace de travail. Pour plus d’informations, voir « Génération manuelle de

projets » à la page 81, « Gestion des fichiers d’application du projet » à la page 52 et « Options de génération avancées »

à la page 81.

Affichage des erreurs de génération dans la vue Erreurs

Les erreurs détectées par le compilateur au cours de la génération s’affichent dans la vue Erreurs des perspectives Développement et Débogage, ainsi que dans l’éditeur de code, dans lequel les lignes contenant des erreurs sont signalées par un x, comme l’illustre l’exemple suivant.

Pour plus d’informations sur l’utilisation de la vue Erreurs, voir « Utilisation de la vue Erreurs » à la page 125.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Erreurs d’environnement Eclipse dans le fichier journal

Des erreurs générées par l’environnement Eclipse sont susceptibles de se produire. Elles surviennent généralement lorsque des ressources (des fichiers SWC, par exemple) ne sont pas trouvées à l’exécution. Dans ce cas, les messages d’erreur apparaissent dans le fichier journal des erreurs Eclipse. L’emplacement par défaut de ce fichier journal sous Windows est le suivant : \Documents and Settings\nom_utilisateur\workspace\.metadata\.log. Sous Mac, l’emplacement par défaut se trouve également dans le répertoire de l’espace de travail. Les fichiers et dossiers commençant par un point y sont toutefois masqués par défaut.

Personnalisation des scripts de génération avec Apache Ant

Vous pouvez modifier et étendre le processus de génération standard en faisant appel à Apache Ant, outil de génération Java à code source libre. Pour plus d’informations sur la création de générateurs personnalisés, voir « Personnalisation des générations avec Apache Ant » à la page 83.

Options du compilateur Flex

Vous pouvez modifier les paramètres par défaut du compilateur Flex utilisé par Flash Builder. Pour afficher les paramètres par défaut et en modifier les valeurs, ouvrez la page des propriétés du compilateur Flex. Dans le menu Flash Builder, sélectionnez Projet > Propriétés > Compilateur Flex.

Version SDK Flex

Le SDK par défaut pour Flash Builder 4 est Flex 4.0. Cependant, si votre projet utilise une version spécifique, telle que Flex 3.4, Flash Builder compile les applications du projet à l’aide du SDK Flex spécifié.

Vous pouvez définir comme paramètre par défaut un SDK Flex spécifique ou vous pouvez définir que la compilation soit effectuée en utilisant la compatibilité avec Flex 3. La spécification de la compatibilité ascendante affecte certains comportements, tels que les règles de présentation, les marges intérieures et les espaces, les habillages ainsi que d’autres paramètres de style. Elle a également une incidence sur les règles d’analyse des fichiers de propriétés. La définition de la version de compatibilité n’applique pas toutes les différences existant entre les versions.

Pour plus d’informations, voir Backward compatibility.

Options d’Adobe Flash Player

La version par défaut de Flash Player utilisée par le compilateur est la version minimale requise par le SDK Flex utilisé pour la compilation.

Vous pouvez définir une version spécifique de Flash Player pour l’application. Les fonctionnalités nécessitant une version ultérieure de Flash Player ne seront pas compilées dans l’application.

Options du compilateur

Flash Builder fournit des cases à cocher pour les options suivantes du compilateur :

• Utiliser le moteur de texte Flash dans les composants MX

Le moteur de texte Flash (Flash Text Engine, FTE) est une bibliothèque qui fournit des contrôles de texte dotés d’un ensemble complet d’options de formatage. Tous les composants Spark du package spark.components prennent en charge FTE. Voir Using embedded fonts.

Certains contrôles MX fournissent une prise en charge de FTE. Les contrôles MX prenant en charge FTE utilisent les mêmes polices intégrées que les composants Spark utilisant FTE. Voir Using FTE in MX controls.

• Copier les fichiers non imbriqués dans le dossier de sortie

• Générer un fichier SWF accessible

Dernière mise à jour le 29/4/2010

Cette option active les fonctionnalités d’accessibilité lors de la compilation de l’application ou du fichier SWC. Pour plus d’informations sur l’utilisation des fonctionnalités d’accessibilité avec Flex, voir Accessible applications.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

• Activer la vérification stricte

Lorsque la vérification stricte est activée, le compilateur imprime des appels de propriété et de fonction non définis. Il effectue également une vérification de type au moment de la compilation pour les affectations et les options fournies aux appels de méthode.

• Activer les avertissements

Cette option active des avertissements spécifiques. Pour plus d’informations, voir Viewing warnings and errors.

Vous pouvez également spécifier des arguments de compilateur disponibles avec la ligne de commande mxmlc compiler. Vous pouvez définir les valeurs de la plupart des options du champ Arguments de compilateur supplémentaires en utilisant la syntaxe de la ligne de commande. Pour plus d’informations sur la syntaxe pour la définition des options dans la boîte de dialogue Compilateur Flex, voir About the command-line compilers.

Dans le champ Arguments de compilateur supplémentaires, vous pouvez remplacer un chemin vers le répertoire du SDK par le jeton

-include-libraries "${flexlib}/libs/automation.swc" "${flexlib}/libs/automation_agent.swc"

${flexlib}, comme l’illustre l’exemple suivant :

Enveloppe HTML

Outre les fichiers SWF, le compilateur Flash Builder génère également une enveloppe HTML que vous pouvez utiliser lors du déploiement de l’application. Les options suivantes sont disponibles :

• Générer le fichier d’enveloppe HTML

• Vérifier la version du lecteur cible

Lorsque cette option est activée, l’application compilée vérifie que la version de Flash Player est correcte.

Si l’option d’utilisation de l’installation rapide est activée, l’application exécute un fichier SWF dans le lecteur Flash Player existant pour mettre à niveau les utilisateurs vers la dernière version du lecteur.

• Activer l’intégration avec le navigateur

Cette option active la liaison profonde. La liaison profonde permet aux utilisateurs de parcourir leurs interactions avec l’application en utilisant les boutons Précédent et Suivant de leur navigateur.

Accès par ligne de commande aux compilateurs de structure Flex

Vous pouvez accéder directement par ligne de commande aux compilateurs de structure Flex (mxmlc et compc). Lorsque vous installez Flash Builder, l’invite de structure Flex se trouve dans le menu de démarrage Windows (Programmes > Adobe). Pour plus d’informations, voir About the command-line compilers dans Utilisation d’Adobe Flex 4.

Personnalisation des générations de projet

Flash Builder vous permet de générer des applications automatiquement en utilisant les paramètres de projet par défaut. Cette méthode est recommandée pour la génération d’applications. Vous pouvez toutefois personnaliser la génération de projets en fonction de vos besoins. Vous avez ainsi la possibilité par exemple de sélectionner un autre dossier de sortie par défaut ou de modifier les options du compilateur.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Jeu de composants (MX + Spark ou MX uniquement)

Par défaut, les projets Flex mettent à la disposition des applications l’ensemble des composants, c’est-à-dire les composants Spark fournis avec Flex 4 et les composants MX livrés avec Flex 3.

Il est possible toutefois que dans certains cas, vous ne souhaitiez faire appel qu’aux composants MX fournis avec Flex 3. Vous pouvez par exemple disposez d’un projet Flex 3 dans lequel vous ne voulez pas introduire les nouveaux composants Spark mais pour lequel vous souhaitez toutefois bénéficier des avantages des fonctionnalités introduites avec Flex 4 et Flash Builder 4 (nouvelle syntaxe d’états, fonctions de compilation améliorées et autres fonctionnalités de langage). Dans ce cas, activez l’option MX uniquement pour le jeu de composants.

L’activation de cette option supprime du chemin de génération toutes les bibliothèques associées à Spark. Lors de la conversion d’un projet Flex 4 en projet MX uniquement, Flash Builder n’apporte aucune modification au code du projet. Vous devrez mettre à jour le code manuellement afin d’en supprimer toute référence aux composants et aux bibliothèques Spark.

Liaison de la structure des applications

Par défaut, les classes d’application de la structure Flex 4 utilisent la liaison dynamique. Au lieu de compiler toutes les classes dans le fichier SWF de l’application (liaison statique), certaines classes sont chargées à partir de la bibliothèque partagée à l’exécution (Runtime Shared Library, RSL). Les applications créées avec une liaison dynamique sont dotées de fichiers SWF plus petits, ce qui permet de les télécharger plus rapidement. En revanche, ces applications utilisent plus de mémoire, toutes les classes de la structure étant chargées, y compris celles dont vous n’avez pas besoin. Pour plus d’informations, voir Bibliothèque partagée à l’exécution.

Vous pouvez modifier les propriétés d’un projet afin de personnaliser ce comportement pour toutes les applications d’un projet. Après avoir sélectionné un projet, dans le menu de Flash Builder, choisissez Projet > Propriétés > Chemin de génération Flex > Chemin d’accès à la bibliothèque.

Par défaut, Flash Builder utilise le comportement par défaut du SDK pour la liaison des structures. Pour Flex 4, il s’agit de la liaison dynamique des bibliothèques partagées à l’exécution (RSL) ; pour Flex 3, de la liaison statique. Utilisez le menu déroulant Liaison de structure pour remplacer le comportement par défaut.

Pour le SDK Flex 4, les options suivantes sont activées par défaut :

• Vérifier les condensés RSL

Vérifie que le condensé de la bibliothèque RSL correspond à celui stocké dans l’application au moment de la compilation lorsque l’application a été liée à la bibliothèque RSL interdomaines. Pour plus d’informations, voir About RSL digests.

• Utiliser les bibliothèques RSL locales de débogage lors du débogage

Utilise les bibliothèques RSL locales lors du débogage de l’application. L’utilisation des bibliothèques RSL locales vous permet d’intervenir dans les fichiers RSL de débogage. Cette option est ignorée lors de l’exportation d’une version validée.

• Déterminer automatiquement l’ordre de la bibliothèque, en fonction des dépendances

Si cette option est activée, Flash Builder détermine l’ordre des bibliothèques en fonction des dépendances au sein des bibliothèques. Pour personnaliser l’ordre des bibliothèques, désactivez cette option et indiquez l’ordre voulu à l’aide des boutons Haut et Bas.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Activation et désactivation des générations automatiques

En configuration autonome, Flash Builder génère vos projets automatiquement. En configuration plug-in, vous devrez activer cette option. Flash Builder est conçu pour générer les projets automatiquement. La désactivation de cette option empêche le compilateur de détecter les erreurs de syntaxe et d’afficher les avertissements et les messages d’erreur au fur et à mesure de la saisie du code. Pour plus d’informations sur la génération manuelle de projets, voir « Génération manuelle de projets » à la page 81.

Effectuez l’une des opérations suivantes :

• Sélectionnez Projet > Générer automatiquement.

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

l’option Générer automatiquement.

Cette option a une incidence sur tous les projets de l’espace de travail.

Définition d’un dossier de sortie de projet

Lorsque vous créez un projet dans Flash Builder, le résultat de la création est généré par défaut dans le dossier de sortie. Les projets LiveCycle Data Services ES faisant appel à l’option de compilation sur le serveur dérogent à cette règle. A son exécution, l’application est en effet compilée sur le serveur.

Vous pouvez modifier le nom de ce dossier à la création du projet ou une fois le projet créé. Vous avez en outre la possibilité de créer un dossier ou de sélectionner un dossier existant de l’espace de travail.

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

2 Cliquez avec le bouton droit de la souris (Windows) ou en maintenant la touche Ctrl enfoncée (Macintosh), puis

sélectionnez Propriétés dans le menu contextuel.

La boîte de dialogue des propriétés du projet apparaît.

3 Sélectionnez la page Chemin de génération Flex.

4 Modifiez le dossier de sortie spécifié en saisissant un nouveau nom ou en recherchant et sélectionnant le dossier

existant du projet.

Remarque : le dossier de sortie d’une application LiveCycle Data Services ES ne peut pas être modifié de cette manière. Son emplacement est en effet contrôlé par le serveur Flex et est accessible uniquement par le biais du fichier Flexconfig.xml du projet.

5 Cliquez sur OK.

Le dossier de sortie existant est remplacé par le nouveau dossier choisi.

Important : la modification du nom du dossier de sortie entraîne la suppression du dossier de sortie d’origine ainsi que de l’ensemble de son contenu. Vous devrez regénérer le projet afin de recréer les fichiers d’application SWF et d’enveloppe HTML.

Modification d’un chemin de génération de projet

Chaque projet possède son propre chemin de génération composé du chemin source et du chemin de bibliothèque (les chemins de génération de projet de bibliothèque sont légèrement plus complexes. Pour plus d’informations, voir « Projets de bibliothèque » à la page 69). Le chemin source correspond à l’emplacement des fichiers source MXML et ActionScript du projet. Le chemin de bibliothèque correspond à l’emplacement des classes de la structure Flex de base ainsi que des composants Flex personnalisés que vous avez créés (sous la forme de fichiers SWC).

Modification du chemin source

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

Dernière mise à jour le 29/4/2010

2 Cliquez avec le bouton droit de la souris (Windows) ou en maintenant la touche Ctrl enfoncée (Macintosh), puis

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

sélectionnez Propriétés dans le menu contextuel. La boîte de dialogue des propriétés du projet apparaît.

3 Sélectionnez la page Chemin de génération Flex (dans le cadre d’un projet ActionScript, sélectionnez la page

Chemin de génération ActionScript).

4 Cliquez sur le bouton Ajouter un dossier pour ajouter un dossier au chemin source.

5 Saisissez le nom du dossier ou cliquez sur le bouton Parcourir pour rechercher l’emplacement des classes

personnalisées.

Vous pouvez également utiliser des variables de chemin afin d’éviter de saisir le chemin complet du système de fichiers. Vous pouvez saisir le nom d’une variable existante ou en créer une. Pour plus d’informations, voir « Création d’une variable de chemin » à la page 80.

6 Apportez les modifications nécessaires au chemin source, puis cliquez sur OK.

Modification du chemin de la bibliothèque

1 Répétez les étapes 1 à 3 de la procédure précédente afin d’accéder à la page des propriétés Chemin de génération

Flex.

2 Cliquez sur l’onglet Chemin d’accès à la bibliothèque.

Le chemin de la bibliothèque contient des références aux classes de la structure Flex contenues dans des fichiers SWC. Un fichier SWC est un fichier d’archivage pour les composants Flex et d’autres ressources (pour plus d’informations, voir « Utilisation des fichiers SWC dans le cadre des projets » à la page 71).

Vous pouvez modifier le chemin vers la structure ou, si vous avez créé des composants Flex personnalisés, ajouter de nouveaux dossiers ou fichiers SWC au chemin de la bibliothèque. Vous avez également la possibilité de supprimer des éléments du chemin.

3 Apportez les modifications nécessaires au chemin de la bibliothèque, puis cliquez sur OK.

Création d’une variable de chemin

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. Définissez par exemple une variable de chemin nommée Classes, puis spécifiez le chemin vers un dossier du système de fichiers. La variable Classes peut ensuite être sélectionnée comme étant l’emplacement du nouveau dossier auquel la relation a été établie. Si le dossier est déplacé, il vous suffit de mettre à jour l’emplacement dans la variable de chemin définie pour que tous les projets reliés à la variable Classes puissent continuer à accéder aux ressources.

Définition ou création d’une variable de chemin

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

2 Cliquez avec le bouton droit de la souris (Windows) ou en maintenant la touche Ctrl enfoncée (Macintosh), puis

sélectionnez Propriétés dans le menu contextuel. La boîte de dialogue des propriétés du projet apparaît.

3 Sélectionnez la page Chemin de génération Flex (dans le cadre d’un projet ActionScript, sélectionnez la page

Chemin de génération ActionScript).

4 Vous pouvez créer une variable pour chaque élément du chemin (dont les dossiers du chemin source et les dossiers

SWC, les projets et les fichiers SWC du chemin de la bibliothèque). A titre d’exemple, cliquez sur le bouton Ajouter un dossier dans l’onglet Chemin source. La boîte de dialogue d’ajout d’un dossier apparaît.

5 Saisissez une variable de chemin conformément au format suivant : ${nom_de_la_variable_de_chemin}.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Remarque : la variable doit exister, sinon la saisie du chemin échoue. Pour obtenir la liste des variables de ressource existantes, sélectionnez Fenêtre > Préférences dans le menu principal, puis Général > Espace de travail > Ressources liées. Les variables de ressources liées peuvent également être gérées à partir de cette page de propriétés.

6 Cliquez sur OK pour ajouter la variable au chemin.

Options de génération avancées

Flash Builder offre des options avancées pour la personnalisation des générations de projet. Vous pouvez par exemple générer des projets manuellement, modifier l’ordre par défaut de génération des projets dans l’espace de travail et créer des générateurs personnalisés avec l’utilitaire Apache Ant.

Génération manuelle de projets

La génération manuelle de projets vous permet de contrôler la durée et l’étendue de la génération. Vous pouvez par exemple générer un seul projet ou un ensemble de projets dans l’espace de travail. Vous pouvez également définir un jeu de documents de projets ou de ressources de projet et ne générer que ces projets et ces ressources. Un jeu de documents est une collection de ressources d’espace de travail (projets, fichiers et dossiers) pouvant être sélectionnées et groupées en fonction de l’utilisation qui en est faite. Pour plus d’informations sur les jeux de documents, voir « Création de jeux de documents » à la page 27.

Les options de génération se situent dans le menu Projet, ainsi que l’illustre l’exemple suivant.

Génération d’un projet unique

1 Dans l’Explorateur de packages, sélectionnez le projet que vous souhaitez générer.

2 Sélectionnez Projet > Générer le projet dans le menu principal.

Le projet sélectionné est généré. Des fichiers d’application validés ou débogués (nouveaux ou mis à jour) sont ajoutés au dossier de sortie du projet.

Remarque : le programme vous invite à enregistrer les fichiers de projet qui ne l’ont pas encore été avant le début de la génération. Pour éviter l’affichage de cette invite, activez l’enregistrement automatique des fichiers avant le début de la génération dans les préférences de l’espace de travail.

Génération de tous les projets dans l’espace de travail

❖ Sélectionnez Projet > Générer tout dans le menu principal.

Tous les projets de l’espace de travail sont générés. Les fichiers d’application sont ajoutés aux dossiers de sortie des projets respectifs. Dans la mesure où vous n’avez pas défini l’enregistrement automatique des fichiers avant le début de la génération, le programme vous invite à les enregistrer.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Génération d’un jeu de documents

Utilisez l’une des méthodes suivantes :

• Sélectionnez Projet > Générer un jeu de documents > Sélectionner un jeu de documents dans le menu principal.

Cliquez sur Nouveau pour créer un jeu de documents. Pour plus d’informations sur la création d’un jeu de documents, voir « Création de jeux de documents » à la page 27.

• Choisissez un jeu de documents existant en sélectionnant Projet > Générer un jeu de documents > Sélectionner un

jeu de documents dans le menu principal.

Tous les projets du jeu de documents sont générés. Les fichiers d’application sont ajoutés au dossier de sortie du projet.

Enregistrement automatique des ressources du projet

Lorsque vous générez des projets manuellement, le programme vous invite à enregistrer toutes les ressources avant de débuter la génération. Pour éviter l’affichage de cette invite, activez l’enregistrement automatique des ressources du projet dans les préférences de l’espace de travail.

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

2 Sélectionnez l’option Sauvegarder automatiquement avant la génération.

3 (Facultatif) Vous pouvez modifier la fréquence d’enregistrement des ressources en saisissant une valeur (en

minutes) dans la zone de texte Intervalle de sauvegarde du plan de travail.

Exécution d’une génération nettoyée

Une fois un projet créé, les générations ultérieures n’impliqueront que les ressources ajoutées ou modifiées. Une génération nettoyée permet de forcer le compilateur Flash Builder à regénérer toutes les ressources d’un projet. Vous pouvez y recourir par exemple pour éliminer toutes les sources potentielles d’un problème survenu au cours du test de l’application.

1 Sélectionnez Projet > Nettoyer dans le menu principal.

2 Choisissez le ou les projets dont vous souhaitez éliminer les fichiers de génération pour les regénérer.

3 Cliquez sur OK.

Modification de l’ordre de génération d’un projet

Flash Builder permet de créer des relations entre les projets ouverts dans l’espace de travail. Vous pouvez par exemple importer les classes ActionScript d’un projet à l’autre. La création de relations entre les projets a une incidence sur l’ordre dans lequel les projets sont générés.

Par défaut, le compilateur génère des projets reliés dans l’ordre garantissant la génération correcte de tous les projets. Prenons l’exemple de deux projets, dont le premier fait référence à des classes contenues dans le second : le second projet est généré en premier. Dans la plupart des cas, le compilateur génère les projets dans l’ordre requis et les applications sont créées correctement sans qu’aucune intervention ne soit nécessaire.

Vous avez cependant la possibilité de modifier l’ordre de génération. Cette modification peut s’avérer nécessaire par exemple si vous avez créé un générateur personnalisé Ant et que vous l’avez associé à un projet de l’espace de travail que vous devez générer avant les autres projets. Pour plus d’informations sur la création de générateurs personnalisés, voir « Personnalisation des générations avec Apache Ant » à la page 83.

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

La boîte de dialogue Ordre de génération présente les options suivantes.

Utiliser l’ordre de génération par défaut L’ordre de génération par défaut dépend des dépendances entre les

projets. Il est géré par le compilateur.

Dernière mise à jour le 29/4/2010

Ordre de génération du projet Vous pouvez définir manuellement l’ordre dans lequel tous les projets de l’espace

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

de travail doivent être générés. Il est également possible de supprimer un projet de la liste définissant l’ordre de génération. Dans ce cas, le projet sera généré après tous les autres projets de la liste.

Itérations maximales lors de la génération avec des cycles En présence de références cycliques dans un projet (ce

que nous vous conseillons d’éviter), vous pouvez définir le nombre de tentatives de génération, afin de permettre au compilateur de générer tous les projets correctement. Par défaut, le nombre maximal d’itérations est 10.

2 Modifiez si nécessaire l’ordre de génération, puis cliquez sur OK.

Personnalisation des générations avec Apache Ant

La création d’un générateur personnalisé vous permet de modifier et d’étendre le processus de génération standard. Flash Builder comporte un script de génération standard intervenant dans la compilation des applications. Vous pouvez, le cas échéant, créer des scripts de génération personnalisés grâce à Apache Ant, outil de génération Java à code source libre.

Le développement de scripts de génération Ant dépasse le cadre de ce guide. Cette rubrique illustre toutefois comment créer un générateur personnalisé et l’appliquer à vos projets.

Vous pouvez appliquer les générateurs personnalisés à tous les types de projet Flash Builder.

Création d’un générateur

1 Dans l’Explorateur de packages, sélectionnez un projet. Cliquez avec le bouton droit de la souris (Windows) ou en

maintenant la touche Ctrl enfoncée (Macintosh) pour afficher le menu contextuel et sélectionnez Propriétés.

2 Sélectionnez la page de propriétés Générateurs. La liste sera plus ou moins longue en fonction du nombre de plug-

ins que vous utilisez. Flash Builder fournit un générateur nommé Flex qui ne peut pas être modifié.

3 Sélectionnez Nouveau.

4 Dans la boîte de dialogue Sélection d’un type de configuration, choisissez le type de configuration approprié. Flash

Builder prend en charge le type Programme. Sélectionnez-le, puis cliquez sur OK pour poursuivre. Définissez les propriétés du nouveau générateur dans la page des propriétés et référencez le script Ant (fichier XML).

5 Cliquez sur OK pour appliquer les valeurs définies au projet.

Pour plus d’informations sur l’utilisation des scripts de génération Ant, voir la documentation Eclipse disponible à l’adresse help.eclipse.org/help31/index.jsp.

Utilisation de plusieurs SDK dans Flash Builder

Flash Builder permet de modifier la version du SDK utilisé pour la compilation des projets. Vous pouvez sélectionner le SDK à la création ou en cours de développement du projet.

Le SDK se compose d’une structure et du compilateur. Le SDK Flex 2.0.1 signifie que vous utilisez la version 2.0.1 des fichiers SWC de la structure Flex et la version 2.0.1 du compilateur Flex. Vous ne pouvez pas utiliser le compilateur Flex 3 avec les fichiers SWC de la structure Flex 2.0.1, par exemple.

La possibilité de modifier le SDK est utile en présence d’un projet développé avec Flex Builder 2.0.1 (qui utilise le SDK Flex 2.0.1) alors que vous exécutez la version 4 de Flash Builder (qui utilise par défaut le SDK Flex 4). En sélectionnant un SDK antérieur pour la génération, vous pouvez préserver la compatibilité avec la dernière version du SDK des projets qui n’ont pas été mis à jour. En outre, si vous travaillez sur un projet utilisant le SDK Flex 2.0.1 mais vous souhaitez faire appel à des fonctions de Flash Builder 4 (restructuration du code, par exemple), vous pouvez mettre à niveau Flash Builder, puis sélectionner un SDK antérieur comme SDK par défaut.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

La modification du SDK après le développement d’un projet entraîne une regénération complète, et non une génération incrémentielle. Flash Builder signale alors toute différence qui aurait généré des erreurs de compilateur, tout comme si le projet avait été développé avec le SDK d’origine. Si vous utilisez par exemple un composant AdvancedDataGrid (introduit dans le SDK Flex 3), puis modifiez le SDK du projet en sélectionnant la version 2.0.1, Flash Builder signale que la classe AdvancedDataGrid est inconnue.

Flash Builder regénère également tous les fichiers de prise en charge des projets, dont les fichiers de gestion de l’historique et de liaisons profondes utilisés par l’enveloppe HTML. Pour les projets SDK Flex 2.0.1, Flash Builder crée les fichiers compatibles de gestion des historiques history.swf, history.html et history.js dans le répertoire des modèles HTML. Pour les projets SDK Flex 3, Flash Builder crée les fichiers compatibles de liaisons profondes history.htm et history.js et historyFrame.html dans le répertoire html-templates/history.

Les options présentes dans Flash Builder varient en outre en fonction du SDK sélectionné. Si vous ajoutez par exemple un module à un projet utilisant le SDK Flex 2.0.1, Flash Builder ne vous propose pas d’optimiser le module. Cette opération devra être effectuée manuellement.

Pour plus d’informations sur les différences entre les SDK Flex 3 et Flex 2.0.1, voir Backward compatibility dans Utilisation d’Adobe Flex 4.

Flash Builder utilise le SDK par défaut pour les nouveaux projets créés. Le SDK par défaut est la dernière version fournie avec Flash Builder. Vous pouvez toutefois sélectionner tout SDK répertorié dans la liste des SDK disponibles dans Flash Builder.

Lorsque vous créez un projet de bibliothèque Flex ou un projet ActionScript, vous pouvez sélectionner le SDK à utiliser dans les boîtes de dialogue Nouveau projet de bibliothèque Flex et Nouveau projet ActionScript.

Ajout d’un nouveau SDK Flex à la liste des SDK disponibles

1 Ouvrez la boîte de dialogue Préférences et sélectionnez Flash Builder > SDK Flex installés.

Elle répertorie les SDK installés. Le nom du SDK par défaut est coché.

2 Cliquez sur Ajouter.

3 Saisissez l’emplacement du SDK dans le champ Emplacement du SDK Flex.

4 Attribuez-lui un nom dans le champ Nom du SDK Flex. Ne saisissez pas le nom d’un SDK existant.

5 Cliquez sur OK pour enregistrer vos modifications.

6 Cliquez de nouveau sur OK pour ajouter le nouveau SDK à la liste des SDK disponibles. Cette liste est gérée dans

l’espace de travail Flash Builder pour tous les projets Flex. Au prochain projet créé, la liste des SDK disponibles comportera également ce nouveau SDK.

Modification de la version de SDK du projet en cours

1 Sélectionnez Projets > Propriétés.

2 Choisissez Compilateur Flex.

3 Cliquez sur Utiliser un SDK spécifique.

4 Sélectionnez un SDK dans la liste déroulante. Si elle ne contient pas le SDK recherché, cliquez sur le lien Configurer

les SDK Flex.

5 Cliquez sur OK.

Flash Builder applique le nouveau SDK au projet en cours. Des erreurs et des avertissements peuvent survenir si le projet utilise un code qui n’est pas compatible avec le nouveau SDK.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Sélection d’un nouveau SDK par défaut

1 Ouvrez la boîte de dialogue Préférences et sélectionnez Flash Builder > SDK Flex installés.

Le nom du SDK par défaut est coché.

2 Cochez la case correspondant à un autre SDK pour le définir comme SDK par défaut. Ce SDK sera appliqué à tout

projet, y compris celui en cours, pour lequel l’option Utiliser le SDK par défaut a été sélectionnée dans la boîte de dialogue Compilateur Flex. Un projet paramétré pour utiliser un SDK spécifique ne sera pas concerné par cette modification, et ce même si vous modifiez le SDK par défaut de l’espace de travail.

3 Cliquez sur OK pour enregistrer vos modifications.

4 Cliquez à nouveau sur le bouton OK.

Publication du code source

Une fois qu’une application est prête à être publiée, Flash Builder vous permet de définir si les utilisateurs peuvent visionner le code source ainsi que les ressources de l’application. A l’instar du langage HTML, les utilisateurs peuvent accéder à la source et la visionner dans un navigateur Web en sélectionnant Afficher la source dans le menu contextuel. Le visualiseur de source met en forme et colore le code afin d’en faciliter la lecture. Il constitue également un moyen pratique de partager le code avec d’autres développeurs Flex et ActionScript 3.0.

Activation de l’option d’affichage de la source

1 Ouvrez l’ensemble du projet d’application dans l’éditeur, puis sélectionnez Projet > Exporter vers une version

validée.

2 Sélectionnez Activer l’affichage de la source ou, pour les projets ActionScript, Inclure la source.

3 Cliquez sur Choisir des fichiers source.

4 Dans la boîte de dialogue Publier la source de l’application, sélectionnez le ou les fichiers de l’application à inclure

dans le menu Afficher la source. Par défaut, le fichier principal de l’application est sélectionné.

5 (Facultatif) Modifiez le dossier de sortie de la source. Par défaut, un dossier d’affichage de la source est ajouté au

dossier de sortie du projet.

6 Cliquez sur OK.

Les utilisateurs exécutant l’application peuvent accéder au code source en sélectionnant Afficher la source dans le menu contextuel. Le code source est affiché dans le navigateur Web par défaut sous forme d’arborescence reflétant la structure des ressources (package, dossiers et fichiers) contenues dans l’application (que vous avez décidé de publier). Sélectionnez un élément source pour en afficher le code dans le navigateur. Les utilisateurs peuvent également télécharger tous les fichiers source en cliquant sur le lien vers le fichier Download.zip.

Remarque : les restrictions de sécurité d’Internet Explorer risquent d’entraver l’affichage du code source sur votre ordinateur local. Vous devrez dans ce cas déployer l’application sur un serveur Web.

Ajout du menu d’affichage de la source aux projets ActionScript

Dans les projets Flex, l’ajout de l’élément de menu Afficher la source à l’application s’effectue par l’intermédiaire de l’assistant Exporter vers une version validée. Dans les applications ActionScript, cette option doit être ajoutée manuellement.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

La fonction suivante, contenue dans la structure Flex, peut être utilisée dans un constructeur d’application ActionScript pour activer le menu d’affichage de la source :

com.adobe.viewsource.ViewSource.addMenuItem(obj:InteractiveObject, url:String, hideBuiltins:Boolean = true)

L’exemple suivant illustre l’utilisation de cette fonction dans les applications ActionScript :

package { import flash.display.MovieClip; import com.adobe.viewsource.ViewSource;

public class MyASApp extends MovieClip { public function MyASApp() { ViewSource.addMenuItem(this, "srcview/index.html");

// ... additional application code here } }

}

Cet exemple se base sur l’emplacement par défaut du dossier source (srcview). En cas de modification de cet emplacement, veillez à ce que le code utilise l’emplacement correct.

Génération par ligne de commande de Flash Builder

Flash Builder fournit la tâche Ant <fb.exportReleaseBuild>. Utilisez-la pour implémenter des générations par ligne de commande qui synchronisent les paramètres de génération d’un développeur avec une génération nocturne. Vous pouvez également utiliser la tâche <mxmlc> dans les scripts personnalisés pour la génération nocturne.

Tâche <fb.exportReleaseBuild>

La tâche <fb.exportReleaseBuild> garantit que les paramètres de génération nocturne correspondent exactement à ceux utilisés par les développeurs pendant leur travail de la journée.

Par exemple, si un développeur modifie le chemin de la bibliothèque d’un projet Flex, le nouveau chemin est écrit dans le projet Flash Builder. A son exécution par l’ordinateur de génération nocturne, la tâche <fb.exportReleaseBuild> charge le projet Flash Builder et tous ses paramètres.

La tâche <fb.exportReleaseBuild> présente un autre avantage : elle prend automatiquement en charge les tâches de maintenance supplémentaires qui font normalement partie d’une génération Flash Builder. Par exemple :

• La compilation automatique des projets de bibliothèque associés

• La copie de ressources, telles que les fichiers JPEG, dans le répertoire de sortie

• La copie du modèle HTML, y compris le remplacement des macros en fonction des résultats de compilation

(comme la largeur et la hauteur)

Remarque : la tâche <fb.exportReleaseBuild> nécessite l’installation de Flash Builder sur l’ordinateur de génération nocturne.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Tâche <mxmlc>

Si vous écrivez un script personnalisé qui fait appel à la tâche <mxmlc> (un script Ant, par exemple), vous n’avez pas besoin d’installer Flash Builder sur l’ordinateur de génération. Le SDK Flex doit toutefois s’y trouver. L’ordinateur de génération peut par conséquent se trouver sur une plateforme Linux.

En revanche, l’inconvénient de cette approche est que vous disposez de deux jeux de paramètres de génération à synchroniser : le premier, utilisé par les développeurs au cours de la journée, se trouve dans Flash Builder et le second, sur l’ordinateur de génération nocturne.

Utilisation de la tâche <fb.exportReleaseBuild>

1 Installez Flash Builder sur un ordinateur de génération.

2 Ecrivez build.xml avec fb.exportReleaseBuild comme cible. Par exemple :

<?xml version="1.0"?> <project default="main">

<fb.exportReleaseBuild project="MyProject" />

</target>

</project>

build.xml indique qu’une génération par ligne de commande du projet Flex doit être exécutée avec les paramètres

enregistrés dans les fichiers du projet. Pour plus d’informations sur les paramètres disponibles, voir « Paramètres

de la tâche fb.exportReleaseBuild » à la page 88.

3 Créez un script de génération nocturne qui demande à Eclipse de rechercher un fichier de génération et d’exécuter

sa cible.

Les exemples suivants indiquent

build.xml comme fichier de génération, qui exécute MyTarget.

Si le script de la génération nocturne se trouve sur une plateforme Macintosh, vous pouvez exécuter le script suivant :

WORKSPACE="$HOME/Documents/Adobe Flash Builder"

# works with either FlashBuilder.app or Eclipse.app "/Applications/Adobe Flash Builder/FlashBuilder.app/Contents/MacOS/FlashBuilder" \

--launcher.suppressErrors \

-noSplash \

-application org.eclipse.ant.core.antRunner \

-data "$WORKSPACE" \

-file "$(pwd)/build.xml" MyTarget

Si la génération nocturne est effectuée sur une plateforme Windows, vous pouvez exécuter le fichier de commandes suivant :

set WORKSPACE=%HOMEPATH%\Adobe Flash Builder

REM works with either FlashBuilderC.exe or eclipsec.exe "C:\Program Files\Adobe\Adobe Flash Builder\FlashBuilderC.exe" ^

--launcher.suppressErrors ^

-noSplash ^

-application org.eclipse.ant.core.antRunner ^

-data "%WORKSPACE%" ^

-file "%cd%\build.xml" MyTarget

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Propriété Ant fb.running

La propriété Ant fb.running a la valeur true lorsque Flash Builder est en cours d’exécution. Vous pouvez utiliser cette propriété lorsque vous exécutez des scripts dans Flash Builder. Par exemple :

<fb.exportReleaseBuild ... />

</target>

Tâches Ant d’Eclipse

Eclipse propose plusieurs tâches Ant que vous pouvez incorporer comme cibles dans le script de génération. Par exemple :

• eclipse.incrementalBuild

• elicpse.refreshLocal

• eclipse.convertpath

Consultez la documentation d’Eclipse pour en savoir plus sur ces scripts.

Paramètres de la tâche fb.exportReleaseBuild

Attribut Description Obligatoire ? Valeur par défaut

project Projet à générer. Indiquez le nom d’un projet dans

l’espace de travail Flash Builder, sans chemin d’accès. Par exemple : « MonProjetFlex ».

application Nom de l’application à compiler. Vous pouvez

spécifier simplement le nom de l’application, sans chemin d’accès ou extension (app1, par exemple). Pour éviter toute ambiguïté de nom, vous pouvez spécifier un chemin d’accès complet par rapport à la racine du projet (src/app1.mxml, par exemple). Pour compiler toutes les applications, spécifiez « * » ou omettez cet attribut. Lorsque vous exécutez un projet AIR, vous ne pouvez spécifier qu’une seule application. La valeur « * » n’est pas autorisée.

publishsource Indique si la source de l’application doit être publiée,

ce qui permet à l’utilisateur d’afficher les fichiers source à l’aide du menu contextuel Afficher la source.

locale Indique la langue, par exemple fr-FR. Cette valeur est

transmise au compilateur à l’aide de l’identifiant locale du compilateur. Si spécifiée, cette valeur remplace la langue indiquée dans le champ Arguments de compilateur supplémentaires de Flash Builder.

destdir Dossier de sortie. Le dossier peut être un chemin

relatif ou absolu. Si vous spécifiez un chemin relatif, il est relatif par rapport à la racine du projet. Si vous compilez un projet AIR, le dossier est un répertoire temporaire qui est supprimé après la création du fichier .air.

Oui Sans objet

Non Application par

défaut du projet.

Non false

Non Sans objet

Non bin-release

failonerror Indique si des erreurs de compilation provoquent

l’échec de la génération.

Non true

Dernière mise à jour le 29/4/2010

Attribut Description Obligatoire ? Valeur par défaut

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

verbose La tâche <fb.exportReleaseBuild> génère des

informations supplémentaires. Par exemple, elle répertorie les fichiers qui ont été assemblés dans le fichier AIR et la durée de chaque étape du processus.

package Pour les projets AIR uniquement : indique si le résultat

doit être assemblé dans un fichier .air ou .airi. Si la valeur est true, un fichier .air ou .airi est créé et le répertoire de sortie temporaire (par défaut, le répertoire bin-release défini par l’attribut destdir) est supprimé.

Si la valeur est false, aucun fichier .air ou .airi n’est créé et le répertoire intermédiaire reste intact après la compilation.

destfile Pour les projets AIR uniquement : le nom d’un fichier

.air ou .airi à créer.

Vous pouvez spécifier un chemin relatif ou absolu. Si vous spécifiez un chemin relatif, il est relatif par rapport à la racine du projet.

certificate Pour les projets AIR uniquement : le chemin d’accès

au certificat utilisé pour signer le fichier AIR.

password Pour les projets AIR uniquement : le mot de passe du

certificat qui est utilisé pour signer le fichier AIR. Si cet argument est omis, un message d’erreur s’affiche.

Avertissement : l’utilisation d’une valeur littérale pour un mot de passe risque de compromettre la sécurité.

Non false

Non true

Non appname.air ou

appname.airi (dans la racine du projet)

Non Si cet argument

est omis, un fichier .airi non signé est généré. Il pourra être signé ultérieurement.

Non Sans objet

timestamp Pour les projets AIR uniquement : indique si le fichier

AIR généré inclut un horodatage.

Non false

Assistant Exporter vers une version validée

Lorsque vous exécutez l’assistant Exporter vers une version validée (Projet > Exporter vers une version validée), les paramètres que vous définissez dans l’assistant sont enregistrés dans le fichier .actionScriptProperties. Une génération par ligne de commande qui utilise la tâche fb.exportReleaseBuild récupère les paramètres de l’assistant. L’assistant Exporter vers une version validée enregistre les paramètres suivants :

• Afficher la source

Les fichiers source que vous spécifiez pour l’option Afficher la source sont enregistrés. Si vous définissez le paramètre publishsource sur fb.exportReleaseBuild, l’assistant inclut ces fichiers comme fichiers source pouvant être affichés.

• Pour les projets AIR, tous les fichiers de sortie supplémentaires dont vous déterminez la prise en compte avec le

fichier AIR ou AIRI dans l’assistant.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Exécution des générations par ligne de commande sur Linux et d’autres plateformes

La tâche <fb.exportReleaseBuild> est uniquement prise en charge sur des plateformes Windows et Mac.

Si vous rédigez toutefois un script de génération pour une autre plateforme, utilisez l’option compilateur mxmlc ou compc pour écrire les paramètres de configuration du compilateur dans un fichier. L’option load-config vous permettra ensuite de lire les options de configuration.

Modifiez les paramètres de configuration du fichier en fonction de vos besoins. Par exemple, changez <debug>true</debug> en <debug>false</debug> pour que la génération nocturne génère une version validée.

Exécution d’une génération par ligne de commande à l’aide des paramètres du compilateur Flash Builder

1 Dans Flash Builder, sélectionnez Projet > Propriétés > Compilateur Flex.

2 Dans le champ Arguments de compilateur supplémentaires, indiquez l’argument suivant :

-dump-config nom_du_chemin, où nom_du_chemin spécifie le chemin d’accès absolu à un fichier du système.

3 Appliquez les modifications dans la fenêtre du projet.

Les paramètres du compilateur sont écrits dans le fichier spécifié. Supprimez l’argument -dump-config après avoir vérifié que le fichier a été écrit.

4 Modifiez les paramètres de configuration comme il convient.

5 Dans le script de génération, exécutez le compilateur afin qu’il intègre les paramètres enregistrés du compilateur :

mxmlc -load-config nom_du_chemin

-dump-config dans le

Restrictions pour l’exécution des générations par ligne de commande

Certaines restrictions s’appliquent à l’exécution des générations par ligne de commande à l’aide de la tâche <fb.exportReleaseBuild>.

Exécution des générations par ligne de commande sur des plateformes Mac avec Eclipse 3.4

Dans Eclipse 3.4 sur des plateformes Mac, la génération sans affichage échoue si le chemin d’installation d’Eclipse comporte des espaces.

Exécution des générations par ligne de commande sur des plateformes 64 bits

Flash Builder s’exécute sur des plateformes qui implémentent Java 32 bits. Pour exécuter une génération par ligne de commande sur des plateformes prenant en charge Java 64 bits (Mac OS X Snow Leopard, par exemple), ajoutez aux options de ligne de commande qui sont transmises à Java. Par exemple :

java -d32 ...

-d32

Exécution des applications

Le test d’une application dans Adobe® Flash® Builder™ consiste à exécuter les fichiers SWF de l’application dans un navigateur Web ou dans la version autonome de Flash Player. En présence d’erreurs dans l’application, les outils de débogage vous permettent : de placer des points d’arrêt dans le code et de les gérer ; de contrôler l’exécution de l’application en l’interrompant, la reprenant et la terminant ; d’avancer d’un pas avec entrée ou d’avancer d’un pas sans entrée dans les instructions de code ; de sélectionner les variables critiques à contrôler ; et enfin d’évaluer les expressions de contrôle en cours d’exécution de l’application.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

A propos de l’exécution et du débogage des applications

Une fois les projets générés en applications (voir « Génération de projets » à la page 73), vous pouvez les exécuter et les déboguer dans Flash Builder.

Utilisation de la version de débogage de Flash Player

Pour utiliser la fonction de débogage de Flash Builder, vous devez exécuter la version de débogage de Flash Player. Cette version est disponible sous forme de plug-in ou de contrôle ActiveX pour navigateur ou en tant que version autonome. Elle est installée avec Flash Builder mais peut également être téléchargée à partir du site Web d’Adobe.

Les programmes d’installation de la version de débogage de Flash Player se trouvent dans le répertoire flex_builder_install/Player.

Vous pouvez déterminer par programmation la version de Flash Player exécutée en utilisant la méthode

Capabilities.isDebugger(). Pour plus d’informations, voir Determining Flash Player version in Flex.

Utilisation des configurations de lancement pour exécuter et déboguer des applications

Une configuration de lancement définit le nom du projet, le fichier principal de l’application et le chemin des versions d’exécution et de débogage de l’application. Flash Builder contient une configuration de lancement d’application Flex par défaut. Cette configuration est utilisée pour créer automatiquement des configurations de lancement pour chacun de vos projets. Pour plus d’informations, voir « Gestion des configurations de lancement » à la page 94.

Remarque : dans la configuration plug-in de Flash Builder, la création des configurations de lancement n’est pas automatique. Vous devez en créer une à la première exécution de l’application. Voir « Exécution des applications » à la page 92.

Personnalisation des configurations de lancement

Vous pouvez personnaliser les configurations de lancement que Flash Builder créé automatiquement pour vous. Vous pouvez par exemple commuter le fichier d’application principal ou modifier le chemin afin qu’il dirige vers un fichier SWF plutôt que vers le fichier d’enveloppe HTML. Cela permet d’exécuter et de déboguer les applications directement dans la version autonome de Flash Player plutôt que dans un navigateur Web. Vous pouvez en outre créer des configurations de lancement distinctes pour chaque fichier d’application du projet. Pour plus d’informations, voir « Création ou modification d’une configuration de lancement » à la page 94.

Exécution et débogage des applications dans un navigateur ou dans la version autonome de Flash Player

Par défaut, les chemins d’exécution et de débogage de la configuration de lancement dirigent vers les fichiers d’enveloppe HTML situés dans le dossier de sortie du projet. Les applications sont donc exécutées et déboguées dans la version Flash Player intégrée dans le navigateur Web utilisé. Vous avez toutefois la possibilité d’exécuter et de déboguer les applications dans la version autonome de Flash Player (voir « Exécution du fichier d’application SWF

dans la version autonome de Flash Player » à la page 95). Vous pouvez en outre remplacer le navigateur Web standard

par tout autre navigateur installé sur votre ordinateur (voir « Modification du navigateur Web par défaut » à la page 96).

Remarque : les paramètres de sécurité par défaut d’Internet Explorer 6 (ou des versions ultérieures) bloquent les applications lancées à partir de Flash Builder. Pour les modifier, cliquez sur Outils > Options Internet > Avancé > Sécurité > Autoriser le contenu actif à s’exécuter dans les fichiers de la zone Ordinateur local. Une autre possibilité consiste à autoriser l’exécution de chaque page Internet Explorer après son blocage.

Dernière mise à jour le 29/4/2010

Exécution des outils de débogage à partir de l’éditeur de code

La perspective Débogage Flash contient toutes les fonctions attendues d’un outil de développement puissant et complet. Les outils de débogage vous permettent :

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

• de définir et de gérer des points d’arrêt ;

• de déterminer comment interrompre, reprendre ou quitter l’application ;

• d’avancer d’un pas avec et sans entrée dans le code ;

• de contrôler des variables ;

• d’évaluer des expressions.

Pour plus d’informations sur les outils de débogage Flash Builder, voir « Débogage des applications » à la page 141.

Pour plus d’informations sur la modification du code, voir « A propos de la modification du code dans Flash Builder » à la page 103.

Activation de la perspective de débogage au niveau d’un point d’arrêt

Des points d’arrêt peuvent être ajoutés à des lignes de code exécutables dans l’éditeur de code. Au lancement d’une session de débogage, l’application est exécutée jusqu’au premier point d’arrêt rencontré. A ce stade, la perspective Débogage Flash est activée. Elle vous permet d’analyser l’état de l’application et de la gérer en faisant appel aux outils de débogage. Pour plus d’informations, voir « Lancement d’une session de débogage » à la page 141.

Comparaison des versions déboguées et non déboguées d’une application Flex

Par défaut, Flash Builder génère des versions déboguées du fichier SWF de l’application et les enregistre dans le répertoire bin-debug du projet. Le volume de cette application est supérieur à celui d’une version non déboguée car il contient du code et des métadonnées supplémentaires utilisées par le débogueur.

Pour générer une version non déboguée de l’application Flex, effectuez l’une des opérations suivantes :

• Sélectionnez Projet > Exporter vers une version validée. Cette opération crée un fichier SWF ou un fichier AIR non

débogué dans le répertoire bin-release.

• Ajoutez -debug=false dans le champ Arguments de compilateur supplémentaires. Ceci faisant, un fichier SWF

non débogué sera généré où que vous exportiez le projet.

Exécution des applications

Les applications sont exécutées (et déboguées) en fonction d’une configuration de lancement. La configuration de lancement d’une nouvelle application Flex ou ActionScript spécifie l’emplacement des fichiers d’application générés et du fichier principal de l’application. Les configurations de lancement peuvent être modifiées ou personnalisées. Pour plus d’informations, voir « Gestion des configurations de lancement » à la page 94.

L’exécution des projets conduit à l’ouverture du fichier principal SWF de l’application dans le navigateur Web par défaut ou directement dans la version autonome de Flash Player. Pour plus d’informations sur la modification du navigateur par défaut ou sur l’exécution et le débogage dans la version autonome de Flash Player, voir « Modification

du navigateur Web par défaut » à la page 96 et « Exécution du fichier d’application SWF dans la version autonome de Flash Player » à la page 95.

L’exécution des projets dans Flash Builder peut être effectuée de différentes manières. Vous pouvez par exemple utiliser la commande d’exécution à partir de la barre d’outils et du menu principaux du workbench, de la vue Explorateur de packages et des menus contextuels de l’éditeur de code.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Remarque : le bouton Exécuter comporte deux éléments : le bouton d’action principal et la liste déroulante affichant les fichiers d’application du projet pouvant être exécutés ou débogués. Cliquez sur le bouton d’action principal pour exécuter le fichier d’application par défaut. Vous pouvez également activer la liste déroulante et sélectionner l’un des fichiers d’application du projet ainsi que créer ou modifier une configuration de lancement dans la boîte de dialogue Création, gestion et exécution d’une configuration.

Exécution du projet avec la configuration de lancement par défaut de l’application Flex

1 Dans l’Explorateur de packages, sélectionnez le projet que vous souhaitez exécuter.

2 Dans la barre d’outils principale du workbench, cliquez sur le bouton Exécuter.

Si le projet n’a pas encore été généré, Flash Builder le génère et l’exécute.

L’application s’affiche dans le navigateur Web par défaut ou dans la version autonome de Flash Player.

Vous pouvez exécuter et déboguer tout fichier de projet défini comme fichier d’application. Pour plus d’informations, voir « Gestion des fichiers d’application du projet » à la page 52.

Création d’une configuration de lancement personnalisée

1 Dans l’Explorateur de packages, sélectionnez le projet que vous souhaitez exécuter et ouvrez le fichier principal de

l’application dans l’éditeur.

2 Dans le menu principal, cliquez sur Exécuter > Exécuter > Autre.

3 Dans la boîte de dialogue Création, gestion et exécution des configurations, sélectionnez l’option Application Web

ou Application de bureau.

4 Dans la barre d’outils de la boîte de dialogue, cliquez sur le bouton Crée une nouvelle configuration de lancement.

5 Saisissez le nom de la configuration.

6 (Facultatif) Modifiez si nécessaire les propriétés de la configuration.

7 (Facultatif) Cliquez sur Exécuter pour lancer l’exécution de l’application.

Exécution d’autres fichiers d’application du projet

1 Dans l’Explorateur de packages, sélectionnez le projet que vous souhaitez exécuter.

2 Dans le menu principal, cliquez sur Exécuter > Exécuter > Autre.

3 Sélectionnez l’application que vous souhaitez exécuter.

Exécution d’une configuration de lancement personnalisée

❖ Dans le menu principal, cliquez sur Exécuter > Exécuter > Autre.

Dans la boîte de dialogue Création, gestion et exécution des configurations, sélectionnez une configuration personnalisée existante ou créez-en une. Voir « Gestion des configurations de lancement » à la page 94.

L’action de la commande Exécuter de la version plug-in de Flash Builder est légèrement différente. Elle n’exécute pas le projet sélectionné, mais la dernière configuration à avoir été lancée. Vous pouvez également sélectionner une configuration parmi la liste de celles à avoir été lancées en dernier.

Exécution de la dernière configuration lancée

❖ Cliquez sur le bouton Exécuter situé dans la barre d’outils principale.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Gestion des configurations de lancement

Les configurations de lancement permettent d’exécuter et de déboguer des applications. Flash Builder comporte une configuration de lancement par défaut pour les applications Flex et ActionScript. Lorsque vous exécutez ou déboguez un projet pour la première fois, le programme crée une configuration de lancement spécifique à ce projet. Vous pouvez ensuite modifier le fichier d’application par défaut spécifié dans la configuration de lancement de même que le chemin de lancement par défaut, afin que l’application soit exécutée ou déboguée dans la version autonome de Flash Player plutôt que dans un navigateur Web.

Création ou modification d’une configuration de lancement

Un projet créé et généré est prêt à être exécuté ou débogué. L’exécution et le débogage des applications du projet sont contrôlés par une configuration de lancement. Par défaut, Flash Builder crée une configuration de lancement pour chaque fichier d’application du projet exécuté ou débogué pour la première fois. Les configurations se basent sur la configuration d’application Flex par défaut et peuvent être modifiées.

Les configurations de lancement sont gérées dans la boîte de dialogue Création, gestion et exécution des configurations.

Ouverture et modification d’une configuration de lancement

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

2 Ouvrez un fichier du projet dans l’éditeur de code, puis la boîte de dialogue Création, gestion et exécution des

configurations. Cette opération dépend de la version d’installation de Flash Builder.

• Pour la version autonome de Flash Builder : sélectionnez le projet, puis Exécuter > Exécuter > Autre ou Exécuter

> Déboguer > Autre.

• Pour la version plug-in de Flash Builder avec Eclipse 3.2 : cliquez avec le bouton droit de la souris (ou en

enfonçant la touche Ctrl sur Mac OS) pour afficher le menu contextuel et sélectionnez Exécuter en tant que > Exécuter ou Déboguer en tant que > Déboguer.

Dernière mise à jour le 29/4/2010

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

• Pour la version plug-in de Flash Builder avec Eclipse 3.3 : cliquez avec le bouton droit de la souris (ou en

enfonçant la touche Ctrl sur Mac OS) pour afficher le menu contextuel et sélectionnez Exécuter en tant que > Ouvrir la boîte de dialogue d’exécution ou Déboguer en tant que > Ouvrir la boîte de dialogue de débogage.

3 Sélectionnez la configuration de lancement que vous souhaitez modifier.

Il est possible que plusieurs configurations soient répertoriées. C’est le cas notamment si l’espace de travail contient d’autres projets, si vous avez défini d’autres fichiers de projet comme fichiers d’application ou si d’autres plug-ins Eclipse sont installés.

A la première exécution d’un projet, Flash Builder crée par défaut une configuration de lancement spécifique au projet, reposant sur la configuration d’application Flex par défaut.

Les configurations spécifiques aux applications peuvent être modifiées. Vous pouvez également créer une nouvelle configuration de lancement ou développer une nouvelle configuration à partir d’une configuration existante.

4 Adaptez les paramètres de la configuration, puis cliquez sur Exécuter ou Déboguer.

Création de configurations de lancement pour applications de bureau

Pour les applications de bureau, vous pouvez créer des configurations de lancement qui remplaceront les configurations par défaut fournies par Flash Builder.

Lors de la création ou de la modification d’une configuration de lancement pour une application de bureau, vous devez spécifier des arguments de ligne de commande, un ID d’éditeur, un profil et des paramètres de format d’écran.

Pour les applications de bureau, la valeur de Profil peut être soit desktop, soit extendedDesktop.

Pour créer une configuration de lancement :

1 Sélectionnez Exécuter > Exécuter > Autre.

Pour les configurations de lancement de débogage, cliquez sur Exécuter > Déboguer > Autre.

Pour les configurations de lancement de profilage, cliquez sur Exécuter > Profil > Autre.

2 Sélectionnez le projet de bureau. Cliquez sur le bouton de création d’une configuration de lancement.

Accédez aux onglets Principal, Source et Commun pour spécifier les paramètres de la configuration.

3 Sélectionnez Exécuter, Déboguer ou Profiler pour exécuter l’application avec les paramètres définis.

Cliquez sur Fermer pour enregistrer les paramètres.

Voir aussi

« Gestion des configurations de lancement » à la page 94

Exécution du fichier d’application SWF dans la version autonome de Flash Player

Les applications sont exécutées ou déboguées dans le navigateur Web par défaut. Vous pouvez toutefois en sélectionner un autre (voir « Modification du navigateur Web par défaut » à la page 96). Les applications peuvent également être exécutées ou déboguées dans la version autonome de Flash Player. Il vous suffit pour ce faire de modifier légèrement la configuration de lancement.

Exécution et débogage des applications dans la version autonome de Flash Player

1 Dans la boîte de dialogue Création, gestion et exécution des configurations, sélectionnez la configuration de

lancement que vous souhaitez modifier.

2 Dans l’onglet Principal, désélectionnez l’option Utiliser la valeur par défaut.

Dernière mise à jour le 29/4/2010

3 Cliquez sur le bouton Parcourir du champ Exécuter et/ou du champ Déboguer.

La boîte de dialogue de sélection d’un fichier s’ouvre, répertoriant le contenu du dossier de sortie de la génération.

4 Sélectionnez le fichier d’application SWF du répertoire bin-debug. Ne sélectionnez pas le fichier SWF de l’éventuel

répertoire bin-release, étant donné qu’il ne contient aucune information de débogage.

5 Cliquez sur Ouvrir pour sélectionner le fichier et retourner à la boîte de dialogue de configuration.

6 Validez les modifications apportées et exécutez ou déboguez l’application en utilisant la configuration modifiée.

UTILISATION DE FLASH BUILDER 4

Utilisation des projets

Modification du navigateur Web par défaut

L’exécution et le débogage des applications sont effectués dans le navigateur Web défini par défaut. Vous ne pouvez pas définir un navigateur Web différent pour chaque configuration de lancement. Vous pouvez toutefois modifier le navigateur Web défini pour le workbench, ce qui aura une incidence sur l’exécution et le débogage de toutes les applications.

Modification du navigateur Web par défaut

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

2 Sélectionnez un navigateur dans la liste de ceux installés sur le système.

Remarque : l’option Utiliser le navigateur Web interne ne concerne pas l’exécution et le débogage des applications, ces opérations étant toujours effectuées dans un navigateur Web externe.

Vous pouvez également ajouter des navigateurs à la liste, en supprimer ou éditer ceux qui y sont répertoriés.

3 Cliquez sur OK pour appliquer les modifications.

Création de modules

Adobe® Flash® Builder™ permet de créer, d’ajouter, d’optimiser et de déboguer des modules. Pour plus d’informations sur la rédaction de code de module, voir Creating modular applications.

Création de modules dans Flash Builder

Les étapes suivantes décrivent la procédure de création d’un nouveau module dans Flash Builder. Après avoir créé un nouveau module, vous pouvez le compiler.

Création de modules dans Flash Builder

1 Dans Flash Builder, sélectionnez Fichier > Nouveau > Module MXML. La boîte de dialogue Création d’un(e)

module MXML s’affiche.

2 Sélectionnez un répertoire parent pour le module. Les modules sont habituellement stockés dans le même

répertoire que l’application principale, pour que les chemins relatifs des ressources partagées soient identiques.

Les modules étant exécutables, ils doivent se trouver dans le dossier source du projet.

3 Entrez un nom de fichier pour le module, par exemple MyModule.

4 Entrez les propriétés Largeur, Hauteur et Présentation.

5 Indiquez si vous souhaitez ou non optimiser le module.

ADOBE FLASH BUILDER 4 User Manual

Specifications and Main Features

Frequently Asked Questions

User Manual

Sommaire

Chapitre 1 : A propos de Flash Builder

Possibilités d’utilisation de Flash Builder

Versions de Flash Builder

Programmes d’installation Flash Builder

Client de l’Aide de la communauté Adobe

Chapitre 2 : Workbench Flash Builder

Notions de base du workbench Flash Builder

A propos du workbench

A propos des éditeurs Flash Builder

Indicateurs de code

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

Navigation par code

Formatage de code

Recherche de références et restructuration du code

A propos des perspectives de Flash Builder

Perspective Développement Flash

Perspective Développement Flash en mode Création

Perspective Débogage Flash

Perspective Profil Flash

Autres vues utiles du workbench

Menus, barres d’outils et raccourcis du workbench

Barre d’outils du workbench

Barre d’outils de l’éditeur MXML

Barre d’outils de l’éditeur CSS (uniquement Flex 3)

Utilisation des raccourcis clavier

Extension du workbench Flash Builder

Navigation et personnalisation du workbench Flash Builder

Utilisation des perspectives

Ouverture et changement de perspectives

Définition de la perspective par défaut

Ouverture des perspectives dans une nouvelle fenêtre

Personnalisation d’une perspective

Suppression d’une perspective personnalisée

Réinitialisation des perspectives

Utilisation des éditeurs et des vues

Ouverture des vues

Déplacement et ancrage des vues

Réorganisation des onglets des vues

Changement de vues

Création et utilisation de vues rapides

Filtrage des vues Tâches et Erreurs

Création de jeux de documents

Ouverture de fichiers à éditer

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

Changement d’espace de travail

Personnalisation du workbench

Réorganisation de la barre d’outils principale

Modification des raccourcis clavier

Modification des polices et des couleurs

Modification des polices et des couleurs

Modification des couleurs

Contrôle du clic et du double-clic

Recherche dans le workbench

Recherche de fichiers

Recherche de références et de déclarations

Utilisation de la vue Recherche

Utilisation des modes Source et Création de l’éditeur

Accès aux raccourcis clavier

Définition des préférences du workbench

Chapitre 3 : Utilisation des projets

A propos des projets Flash Builder

Types de projets

Projets Flex

Projets ActionScript

Projets de bibliothèque

Projets Flash Professional

Projets dans l’Explorateur de packages

Création de projets et ouverture de ressources

Ressources des projets

Création de projets Flex

Création d’un projet Flex sans serveur

Création d’un projet Flex avec ASP.NET