Mode d'emploi | Adobe InCopy CS6 Manuel utilisateur

ADOBE® INCOPY® CS6
GUIDE DES SCRIPTS
D’ADOBE INCOPY CS6 :
JAVASCRIPT
© 2012 Adobe Systems Incorporated. Tous droits réservés.
Guide des scripts d’Adobe® InCopy® CS6 : JavaScript
Statut de mise à jour du document
(pour l’intégralité du document ; voir chaque chapitre pour obtenir individuellement le statut de mise à jour de chaque chapitre)
CS6
Mis à jour
Dans tout le document, CS5 est remplacé par CS6 et version 7.0 par version 8.0.
Si ce guide est distribué avec un logiciel comprenant un accord avec l’utilisateur final, ce guide, ainsi que le logiciel qu’il
décrit, sont fournis sous licence et ne peuvent être utilisés ou copiés qu’en accord avec les termes de cette licence. Sauf
autorisation spécifiée dans la licence, aucune partie de ce guide ne peut être reproduite, enregistrée ou transmise sous
quelque forme que ce soit, par quelque moyen que ce soit, électronique, mécanique ou autre, sans l’autorisation écrite
préalable d’Adobe Systems Incorporated. Veuillez noter que le contenu de ce guide est protégé par des droits d’auteur,
même s’il n’est pas distribué avec un logiciel accompagné d’un contrat de licence pour l’utilisateur final.
Les informations contenues dans ce document sont données à titre purement indicatif. Elles peuvent être modifiées sans
préavis et ne constituent pas un engagement de la part d’Adobe Systems Incorporated. Adobe Systems Incorporated ne
peut être tenu pour responsable des erreurs ou des inexactitudes apparaissant dans les informations fournies par ce
guide.
Nous attirons votre attention sur le fait que les illustrations ou images que vous pouvez être amené à incorporer à vos
projets peuvent être protégées par des droits d’auteur, auquel cas leur exploitation sans l’autorisation de l’auteur
constituerait une violation de ces droits. Veillez à obtenir toutes les autorisations requises de la part des auteurs.
Toutes les références à des noms de société dans les modèles cités en exemple sont indiquées uniquement à des fins de
démonstration et ne se réfèrent à aucune organisation existante.
Adobe, le logo Adobe, Creative Suite, InCopy, InDesign, Illustrator et Photoshop sont des marques ou des marques
déposées d’Adobe Systems Incorporated aux Etats-Unis et/ou dans d’autres pays. Microsoft et Windows sont des
marques ou des marques déposées de Microsoft Corporation aux Etats-Unis et dans d’autres pays. Apple et Mac OS sont
des marques d’Apple Computer, Incorporated, déposées aux Etats-Unis et dans d’autres pays. Toutes les autres marques
citées sont la propriété de leurs détenteurs respectifs.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, Californie 95110, Etats-Unis. Avertissement à l’attention des
utilisateurs finaux du gouvernement des Etats-Unis. Le logiciel et la documentation sont des articles commerciaux,
(« Commercial Items »), selon la définition de ce terme dans l’article 48 C.F.R. §2.101, composés d’un logiciel commercial
(« Commercial Computer Software ») et d’une documentation commerciale relative au logiciel (« Commercial Computer
Software Documentation ») selon la définition de ces termes dans l’article 48 C.F.R. §12.212 ou 48 C.F.R. §227.7202, selon
le cas. Conformément aux articles 48 C.F.R. §12.212 ou 48 C.F.R. §§227.7202-1 à 227.7202-4, selon le cas, le logiciel
commercial et la documentation commerciale relative au logiciel sont cédés sous licence aux utilisateurs du
gouvernement des Etats-Unis (a) en tant qu’articles commerciaux uniquement et (b) avec les seuls droits conférés à tout
autre utilisateur final tenu par les termes et conditions stipulés ici. Droits non publiés réservés en vertu de la législation
américaine sur les droits d’auteurs. Adobe Systems Incorporated, 345 Park Avenue, San Jose, CA 95110-2704, Etats-Unis.
Pour les utilisateurs finaux du gouvernement des Etats-Unis, Adobe s’engage à respecter toutes les lois sur l’égalité des
chances, y compris, le cas échéant, les dispositions du décret-loi (Executive Order) 11246, tel qu’amendé, la section 402
de l’Acte d’assistance à la réhabilitation des vétérans du Vietnam (the Vietnam Era Veterans Readjustment Assistance Act)
de 1974 (38 USC 4212) et la section 503 de l’Acte de réhabilitation (Rehabilitation Act) de 1973, tel qu’amendé, ainsi que
les règlements de l’article 41 C.F.R., sections 60-1 à 60-60, 60-250 et 60-741. Les règlements et la clause d’action
affirmative contenus dans la phrase précédente doivent être inclus comme référence.
Sommaire
1
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Utilisation des scripts de ce document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
A propos de la structure des scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Pour plus de détails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
A propos d’InCopy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Relations entre les fichiers InCopy et InDesign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Articles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Géométrie de la page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Métadonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Modèle de document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Différences au niveau de l’interface utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Conception et architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2
Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Installation des scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Exécution de scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Utilisation du panneau Scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Informations relatives au langage JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Autres options de développement JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Utilisation des scripts de ce document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Votre premier script InCopy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Analyse du script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Terminologie des scripts et modèle d’objet InCopy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Terminologie des scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Présentation du modèle d’objet InDesign et InCopy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mesures et positionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
16
19
22
Ajout de caractéristiques à « Hello World » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3
Fonctions de scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Préférences des scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Obtention du script en cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Versionnage des scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ciblage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Interprétation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
27
27
27
Utilisation de la méthode doScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Envoi de paramètres à l’objet doScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Renvoi des valeurs de l’objet doScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Exécution des scripts au lancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Exécution de script par session et main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3
Sommaire
4
4
Texte et saisie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Saisie et importation de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Articles et blocs de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ajout d’un texte à un article . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Remplacement de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Insertion de caractères spéciaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
31
32
32
33
Importation de texte et définition des préférences d’importation de texte . . . . . . . . . . . . . . . . . . . . 33
Exportation de texte et définition des préférences d’exportation de texte . . . . . . . . . . . . . . . . . . . . . 36
Objets texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Sélections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Déplacement et copie de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Objets texte et itération . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
40
41
42
43
Mise en forme du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Définition des valeurs par défaut du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Polices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Application d’une police . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Modification des propriétés d’un texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Modification de la couleur du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Création et application des styles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Suppression d’un style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Importation de styles de paragraphe et de caractère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
44
44
47
47
48
48
49
50
50
Recherche et modification de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Préférences de recherche/modification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Recherche de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Recherche et remplacement d’une mise en forme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Utilisation de l’outil Grep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Recherche de glyphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
51
51
52
53
54
56
Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Correction automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Notes de bas de page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
5
Interfaces utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Présentation des boîtes de dialogue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Votre première boîte de dialogue InCopy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Ajout d’une interface utilisateur à « Hello World » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Création d’une interface utilisateur plus complexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Utilisation de ScriptUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Création d’une barre de progression avec ScriptUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Création d’un panneau avec barre de boutons au moyen de ScriptUI . . . . . . . . . . . . . . . . . 66
Sommaire
5
6
Menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Présentation du modèle de menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Localisation et noms de menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Exécution d’une action de menu à partir d’un script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Ajout de menus et d’éléments de menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Menus et événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Utilisation des objets d’action de menu de script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
7
Evénements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Présentation du modèle de scripts d’événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
A propos des propriétés des événements et de la propagation des événements . . . . . . 78
Utilisation des objets eventListeners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Exemple d’objet eventListener « afterNew » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
8
Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Saisie et importation d’une note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Ajout d’une note à un article . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Remplacement du texte d’une note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Conversion de notes et de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Conversion d’une note en texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Conversion d’un texte en note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Développement et réduction de notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Réduction d’une note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Développement d’une note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Suppression d’une note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Navigation entre les notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Accès à la première note d’un article . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Accès à la note suivante d’un article . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Accès à la note précédente d’un article . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Accès à la dernière note d’un article . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
86
86
86
86
87
Suivi des modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Suivi des modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Navigation entre les modifications suivies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Acceptation et rejet des modifications suivies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Informations sur les modifications faisant l’objet d’un suivi . . . . . . . . . . . . . . . . . . . . . . . . . . .
88
88
89
89
Préférences en matière de suivi des modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Sommaire
6
10
Affectations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Objet affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ouverture des fichiers d’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Itérations dans les propriétés d’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Assemblages d’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
91
91
92
Article d’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Objet article affecté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Itérations dans les propriétés de l’article affecté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
11
XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Meilleure méthode appliquée aux scripts XML dans InCopy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Codage des éléments XML à l’aide des scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Configuration des préférences XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Configuration des préférences d’importation du format XML . . . . . . . . . . . . . . . . . . . . . . . . . 95
Importation du format XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Création d’une balise XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Chargement des balises XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Enregistrement des balises XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Création d’un élément XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Déplacement d’un élément XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Suppression d’un élément XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Duplication d’un élément XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Retrait d’éléments de la structure XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Création d’un commentaire XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Création d’une instruction de traitement XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Utilisation des attributs XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Utilisation des articles XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Exportation du format XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Ajout d’éléments XML à un article . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Association d’éléments XML à du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Application des styles aux éléments XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Utilisation des tableaux XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
1
Introduction
Statut de mise à jour du chapitre
CS6
Inchangé
Ce document décrit les opérations suivantes :
X
Utilisation de l’environnement de création de scripts Adobe® InCopy®
X
Utilisation des fonctions avancées de création de scripts
X
Utilisation et saisie de texte dans un document InCopy, notamment recherche et modification de texte
X
Création de boîtes de dialogue et autres éléments d’interface utilisateur
X
Personnalisation et ajout de menus et création d’actions de menu
X
Réponse aux événements de l’interface utilisateur
X
Utilisation du langage XML, de la création d’éléments XML et l’importation de données XML à l’ajout
d’éléments XML à une mise en page
Utilisation des scripts de ce document
La plupart des scripts présentés dans ce document sont seulement des extraits de script, pas des scripts
entiers. Ils ont pour unique vocation d’illustrer la partie spécifique d’un script correspondant au thème
abordé dans le texte. Vous pouvez copier les lignes de script présentées dans ce document et les coller
dans votre éditeur de scripts ; vous devez toutefois être bien conscient que certains ajustements seront
nécessaires pour que le script puisse fonctionner. En outre, sachez que les scripts copiés à partir de ce
document peuvent contenir des sauts de ligne et autres caractères (provenant de la mise en page du
document) susceptibles d’entraîner des erreurs dans vos scripts.
Tous les scripts présentés dans ce document sont regroupés dans une archive zip, accessible depuis la
page d’accueil des scripts InCopy, à l’adresse suivante :
http://www.adobe.com/products/InCopy/scripting/index.html. Après avoir téléchargé et décompressé
l’archive, déplacez les dossiers correspondant au(x) langage(s) de script de votre choix dans le dossier
Scripts Panel du dossier Scripts, situé dans le dossier de l’application InCopy. Vous pouvez alors exécuter
les scripts à partir du panneau Scripts de votre application InCopy.
A propos de la structure des scripts
Les exemples de script sont tous écrits à l’aide d’un modèle commun incluant les fonctions « main »,
« mySetup », « mySnippet » et « myTeardown ». Nous avons choisi de procéder ainsi afin de simplifier les
tests automatisés et la publication ; cette méthode n’est pas justifiée pour la construction de vos scripts. En
général, la partie du script qui vous intéressera se trouvera dans la fonction « mySnippet ».
7
CHAPITRE 1: Introduction
Pour plus de détails
8
Pour plus de détails
Vous trouverez plus de détails sur la création de scripts InCopy sur le forum des utilisateurs consacré aux
scripts InCopy (en anglais), à l’adresse suivante : http://www.adobeforums.com. Dans ce forum, les
créateurs de scripts peuvent poser des questions, envoyer des réponses et partager leurs dernières
compositions. Le forum contient plusieurs centaines d’exemples de scripts.
A propos d’InCopy
InCopy est une application d’édition de texte collaborative développée pour une utilisation conjointe avec
Adobe InDesign®. InCopy vous permet d’effectuer le suivi des modifications, d’ajouter des notes d’édition
et d’adapter le texte à l’espace qui lui est réservé. InCopy utilise le même moteur de composition du texte
qu’InDesign, c’est pourquoi ces deux applications ajustent la copie dans une page avec une composition
identique.
InCopy est destinée à l’environnement d’édition. Cette application permet aux divers participants du flux
de travail éditorial de collaborer à la création de magazines, journaux et publications d’entreprises, en
favorisant l’édition simultanée du texte et de la mise en page. Elle est principalement utilisée par les
éditeurs, rédacteurs, correcteurs, réviseurs et autres intervenants.
InCopy partage de nombreux panneaux et palettes avec InDesign, mais propose également ses propres
éléments d’interface utilisateur.
Relations entre les fichiers InCopy et InDesign
Les relations entre les fichiers InDesign et InCopy sont importantes en raison de la répartition du travail au
sein du flux de travail de publication qui se produit lorsque les mêmes éléments sont ouverts et modifiés
dans les deux applications.
Il existe deux scénarios courants d’exportation à partir d’InCopy :
X
Vous pouvez exporter un fichier ICML (basé sur IDML).
X
Vous pouvez exporter un fichier INCX (basé sur INX).
Il existe deux scénarios courants d’exportation à partir d’InDesign qui font appel à InCopy :
X
Les articles exportés à partir d’InDesign en tant que fichiers InCopy sont des fichiers ou des flux XML ;
les modules externes InCopyExport et InCopyWorkflow chargés dans InDesign proposent cette
fonction. Cette approche comporte certaines implications d’ordre pratique : les fichiers InCopy sont
beaucoup plus petits, ils transitent plus rapidement sur les réseaux, ils ne contiennent pas de
géométrie de page, et les données des fichiers/flux XML peuvent être utilisées sans InDesign/InCopy
(pour les moteurs de recherche, outils de base de données, etc.).
X
Les groupes à l’intérieur d’un article (titre, auteur, copie, graphiques ou légendes) peuvent également
être exportés. InDesign et Incopy prennent en charge la création de groupes avec les fichiers
d’affectation, qui permettent de gérer les fichiers en ajoutant un fichier supplémentaire utilisé pour le
suivi des autres fichiers. Une affectation regroupe plusieurs fichiers dont les contenus sont attribués à
une seule personne en vue d’une tâche précise : copie, édition, mise en page et/ou rédaction, par
exemple. Les articles figurant dans une affectation sont exportés sous la forme de fichiers InCopy.
Les informations relatives à la géométrie et les relations entre les fichiers sont incluses dans le fichier
d’affectation. InDesign permet à l’utilisateur d’exporter un ensemble d’articles spécifique à l’aide
d’une affectation. InCopy ouvre tous les articles situés dans une affectation (sous la forme d’une seule
unité). Pour plus de détails, voir le Chapitre 10, « Affectations ».
CHAPITRE 1: Introduction
Relations entre les fichiers InCopy et InDesign 9
Articles
Chaque fichier InCopy constitue un article. Un document InDesign contient plusieurs articles modulables
en fonction du nombre de documents InCopy, via le processus d’exportation. Ces articles InDesign
exportés contiennent un lien accessible dans le panneau Liens (InDesign) ou dans le panneau Affectations
en tant que fichiers d’affectation (InCopy).
InCopy ne conserve pas le lien au document InDesign auquel il est associé (s’il en existe un). InDesign
conserve les liens avec les fichiers InCopy en tant que liens bidirectionnels.
Les articles peuvent être structurés en langage XML. Ceci signifie que des données XML peuvent contenir
d’autres données XML. Cette fonction peut servir à concevoir une structure de données dans laquelle le
texte brut d’un article est englobé dans une structure externe contenant des données spécifiques à
InCopy (les styles, par exemple).
Dans InCopy, vous pouvez enregistrer le contenu au format ICML/INCX ou, si l’article possède une
structure, la structure logique peut être exportée au format XML.
Un fichier ICML ou INCX peut contenir à la fois des données et du texte balisé InCopy. Si le fichier est
exporté sous forme de données XML, les données spécifiques à InCopy sont supprimées. Il ne reste alors
que le contenu balisé moins les informations relatives au style.
Géométrie de la page
Les fichiers InCopy ne contiennent pas de géométrie de page. Si la géométrie est requise, elle doit être
obtenue à partir du document InDesign. InCopy peut ouvrir des documents InDesign et extraire les
informations de conception et les liens vers les articles exportés. Lorsque la géométrie de page est
souhaitée dans InCopy, les fichiers d’affectation peuvent également être fournis.
Métadonnées
La plate-forme XMP (Extensible Metadata Platform) d’Adobe propose une méthode pratique pour créer,
échanger et gérer les métadonnées. Les fichiers InCopy prennent en charge XMP.
Tout comme InDesign propose la commande Fichier > Informations pour afficher les données XMP, InCopy
propose la commande Fichier > Informations sur le fichier. Les intégrateurs de systèmes peuvent
conserver ces données ou les éliminer lors de l’exportation.
Les métadonnées ajoutées aux articles par les développeurs de logiciels tiers sont conservées lorsqu’elles
sont intégrées à des documents InDesign. Vous pouvez visualiser les métadonnées ajoutées dans InDesign
(panneau Liens, boîte de dialogue Informations) ou InCopy. Par ailleurs, les développeurs de logiciels tiers
peuvent ajouter des fonctionnalités à InDesign de manière à afficher ces métadonnées dans une interface
utilisateur personnalisée.
Un point d’extension permet aux prestataires de services d’ajouter du contenu de métadonnées aux
fichiers InCopy. Pour plus de détails, voir le Chapitre 11, « XML ».
CHAPITRE 1: Introduction
Conception et architecture 10
Modèle de document
Les documents InDesign sont à la base de tout le contenu InDesign. InCopy aussi utilise les documents
InDesign, mais il ne s’agit pas du type par défaut.
Dans InDesign et InCopy, le document de base est toujours une base de données. Toutefois, dans InCopy
ce document peut être incomplet. Dans InDesign, le document principal type est un fichier InDesign
ouvert, mais il peut également s’agir d’un fichier INX ou IDML ouvert, qui se révèle généralement être un
document InDesign non enregistré.
InCopy possède d’autres permutations. Il existe le fichier InDesign de base, ainsi qu’un nouveau document
comportant un article InCopy (ou du texte brut ou RTF) importé. De même, il existe les fichiers d’affectation
IDML et INX qui possèdent une partie d’un fichier InDesign stockée dans un fichier XML. Le modèle de
document InDesign/InCopy correspond à l’ensemble de modules externes du modèle de base requis, dont la
version évolue en fonction des modifications dans le temps. Il est important que tous les scripts IDML/INX
fonctionnent à la fois dans InDesign et InCopy afin que les documents puissent être déplacés d’une
application à l’autre tout en étant fidèlement restitués.
Différences au niveau de l’interface utilisateur
InDesign et InCopy ont de nombreux panneaux en commun, mais InCopy dispose d’un affichage plus
petit et possède plusieurs barres d’outils supplémentaires le long des bordures supérieure, inférieure et
gauche. Vous pouvez ancrer la plupart des panneaux InCopy sur ces barres pour les rendre visibles en
toutes circonstances, mais avec une taille plus petite.
InCopy dispose d’une fenêtre personnalisée à plusieurs vues, dans une fenêtre principale ayant trois
onglets : Mode Epreuve en placard, Mode Article et Mode Mise en page. Le Mode Mise en page est le
mode d’affichage principal d’InDesign. Les modes Epreuve en placard et Article font partie du mode
éditeur, avec et sans fins de lignes exactes, respectivement.
Conception et architecture
Relation article/fichier
Le format ICML est la représentation IDML d’un article InCopy. Il représente la future direction
d’InDesign/InCopy et constitue un choix judicieux si vous devez modifier un fichier en dehors d’InDesign.
Format ICML
Chaque fichier ou flux InCopy utilise le langage XML. Ceci permet de facilement analyser les fichiers
InCopy et de les ouvrir dans n’importe quel éditeur de texte.
Format INCX
Le format INCX est la représentation INX d’un article InCopy. Ce format n’est pas aussi convivial que le
format ICML, mais il prend en charge les flux de travail INCX.
CHAPITRE 1: Introduction
Conception et architecture 11
Opérations sur un document
InCopy fournit des implémentations par défaut des opérations exécutées sur les documents (actions sur
les fichiers), comme Nouveau, Enregistrer, Enregistrer sous, Enregistrer une copie, Ouvrir, Fermer, Version
précédente et Mettre à jour la maquette. Toutes ces actions exécutables sur les fichiers InCopy sont situées
dans un seul module externe (InCopyFileActions) sous la forme d’un code source. Les développeurs de
logiciels ou les intégrateurs de systèmes sont supposés le remplacer par leurs propres implémentations
afin de personnaliser l’interaction pour leur système de flux de travail.
Utilisation des métadonnées XMP
Les utilisateurs peuvent saisir ou modifier des métadonnées en sélectionnant Fichier > Informations sur le
fichier. Ces métadonnées sont enregistrées dans le fichier InCopy. Les développeurs de logiciels et les
intégrateurs de systèmes peuvent créer et stocker leurs propres métadonnées à l’aide du SDK XMP.
2
Prise en main
Statut de mise à jour du chapitre
CS6
Mis à jour
Références à CS5 supprimées ou modifiées.
Les scripts représentent la fonction la plus puissante d’Adobe® InCopy®. Aucune autre fonction (outil,
panneau ou boîte de dialogue visible sur l’interface utilisateur du programme) n’est aussi rapide, facile et
économique que le script.
Le présent document s’adresse à tous les utilisateurs d’InCopy. Si vous n’avez jamais créé de script, ce
document vous aidera à commencer. Si vous avez déjà créé des scripts pour d’autres applications, vous
apprendrez à appliquer vos connaissances aux scripts InCopy. Ce document traite également de l’installation
et de l’exécution d’un script InCopy, ainsi que des capacités et limites des scripts InCopy. Vous y trouverez
aussi des indications sur les logiciels dont vous avez besoin pour commencer à écrire vos propres scripts.
A l’aide des scripts, vous pouvez reproduire la plupart des opérations que vous exécutez dans l’interface
utilisateur InCopy. Vous pouvez entrer du texte et le mettre en forme, rechercher et modifier du texte,
ajouter des notes et imprimer ou exporter les pages du document. Toute opération apportant une
modification au document ou à son contenu peut être réalisée à l’aide d’un script. Les scripts vous
permettent même d’exécuter certaines opérations qui ne sont pas réalisables avec l’interface utilisateur.
Les scripts permettent de créer des menus, d’ajouter des éléments de menu, de créer et d’afficher des boîtes
de dialogue et des panneaux, mais également de répondre aux sélections de l’interface utilisateur. Ils peuvent
lire et écrire des fichiers texte, analyser des données XML et communiquer avec d’autres applications.
Les scripts permettent d’effectuer toutes sortes de tâches, des plus simples (telles que la définition d’un taquet
de tabulation à l’emplacement du pointeur de texte) aux plus complexes, comme la définition d’un ensemble
complet de fonctions. Vous pouvez commencer avec des scripts simples qui n’exécutent qu’une action, puis
passer aux scripts qui automatisent le flux de travail de publication tout entier.
Les tâches que vous ne pouvez pas exécuter à l’aide de scripts, telles que la définition d’un espace de
travail ou d’un ensemble de raccourcis clavier, sont associées à l’interface utilisateur. En outre, les scripts ne
permettent pas d’ajouter de nouveaux types d’objets à un document InCopy ni d’ajouter une nouvelle
fonctionnalité de base au programme, telle qu’un moteur de composition de texte. Pour ce type
d’extension, vous devez avoir recours au kit SDK (Software Developer’s Kit) d’InCopy, qui vous indique
comment écrire des modules externes compilés à l’aide du langage C++.
Ce document traite d’Adobe InDesign® et d’InCopy, car InCopy est quasiment toujours utilisé en
association avec des documents InDesign. En outre, la création de scripts InDesign est très proche de celle
de scripts InCopy. Vous trouverez de plus amples détails sur la création de scripts InDesign dans le
Didacticiel de scripts Adobe InDesign et le Guide des scripts d’Adobe InDesign.
Installation des scripts
Pour installer un script InCopy, il vous suffit de placer le fichier de script dans le dossier Scripts Panel du
dossier Scripts, situé dans le dossier de l’application InCopy.
Vous pouvez également placer le script dans le dossier Scripts Panel de votre dossier de préférences
utilisateur. Vous trouverez le dossier de vos préférences utilisateur à l’emplacement suivant, où
<username> correspond à votre nom d’utilisateur et le symbole ~ (tilde) représente le volume système :
Mac OS® :
/Users/<username>/Library/Preferences/Adobe InCopy/
Version 8.0/<locale>/Scripts
12
Prise en main
Exécution de scripts 13
Windows® XP : C:\Documents and Settings\<username>\Application Data\Adobe\InCopy\
Version 8.0\<locale>\Scripts
Windows® Vista :C:\Users\<username>\App Data\Roaming\Adobe\InCopy\
Version 8.0\<locale>\Scripts
Une fois dans le dossier, le script s’affiche dans le panneau Scripts de l’application InCopy (choisissez la
commande Fenêtre > Scripts pour afficher ce panneau).
Vous pouvez également placer des alias ou des raccourcis de scripts (ou de dossiers contenant des scripts)
dans le dossier Scripts Panel. Ils s’afficheront dans le panneau Scripts.
Exécution de scripts
Pour exécuter un script, vous devez afficher le panneau Scripts (choisissez la commande Fenêtre > Scripts), puis
cliquer deux fois sur le nom du script dans le panneau Scripts. De nombreux scripts affichent des éléments
d’interface utilisateur (boîtes de dialogue ou panneaux, par exemple), ainsi que des messages d’alerte, si nécessaire.
Utilisation du panneau Scripts
Le panneau Scripts peut exécuter des AppleScripts (fichiers avec l’extension .spt, .as ou .applescript)
compilés ou non, des JavaScripts (fichiers avec l’extension .js ou .jsx), des VBScripts (fichiers avec
l’extension .vbs) ou des programmes exécutables à partir de ce panneau.
Pour modifier un script affiché dans le panneau Scripts, cliquez deux fois sur le nom du script tout en
maintenant la touche Option (Mac OS) ou Alt (Windows) enfoncée. Le script s’ouvre dans l’éditeur défini
pour son type de fichier.
Pour ouvrir le dossier contenant un script affiché dans le panneau Scripts, cliquez deux fois sur le nom du
script tout en maintenant la touche Commande (Mac OS) ou les touches Ctrl+Maj (Windows) enfoncées.
Vous pouvez également choisir la commande Faire apparaître dans le Finder (Mac OS) ou Faire apparaître
dans l’Explorateur (Windows), dans le menu du panneau Scripts. Le dossier contenant le script s’ouvre
dans le Finder (Mac OS) ou l’Explorateur (Windows).
Les scripts s’exécutent sous la forme d’une série d’opérations (actions), ce qui signifie que vous pouvez annuler les
modifications apportées au document par le script en choisissant la commande Annuler dans le menu Edition.
Vous pouvez ainsi dépanner un script, en revenant aux étapes précédentes pour chaque modification.
Pour ajouter un raccourci clavier à un script, choisissez la commande Edition > Raccourcis clavier,
sélectionnez un ensemble de raccourcis modifiable dans le menu Ensemble, puis sélectionnez
l’option Scripts dans le menu Zone du produit. Une liste de scripts apparaît dans le panneau Scripts.
Sélectionnez un script, puis affectez-lui un raccourci clavier comme vous le feriez pour n’importe quelle
autre fonction d’InCopy.
Informations relatives au langage JavaScript
La prise en charge de JavaScript par InCopy repose sur l’implémentation de JavaScript pour Adobe
appelée ExtendScript. L’interpréteur ExtendScript est conforme à la norme ECMA 262 en vigueur
pour JavaScript. Toutes les fonctions de langage JavaScript 1.5 sont prises en charge. Adobe Illustrator®,
Adobe Photoshop®, ainsi que d’autres produits Adobe Creative Suite® utilisent également l’interpréteur
ExtendScript JavaScript.
Même s’il est possible d’écrire des scripts dans d’autres versions de JavaScript, telles que JavaScript OSA de
Late Night Software (Mac OS) ou Microsoft® JScript (Windows), les termes utilisés dans ces langages ne
sont pas les mêmes que ceux utilisés dans ExtendScript. Les exemples ExtendScript ne fonctionnent pas
dans d’autres versions JavaScript.
Prise en main
Utilisation des scripts de ce document
14
REMARQUE : les outils et fonctions ExtendScript sont utilisés dans plusieurs produits Adobe. Cela a mené à
la consolidation de toute la documentation ExtendScript. Pour en savoir plus sur les utilitaires JavaScript,
tels que l’utilitaire ExtendScript Toolkit (environnement de développement et inspecteur de modèle
d’objet JavaScript) et le module d’interface utilisateur ScriptUI, voir le Guide des outils JavaScript
Creative Suite 5.
Autres options de développement JavaScript
Vous pouvez utiliser ExtendScript Toolkit pour créer des scripts JavaScript explicitement pour InCopy, ou
utiliser Creative Suite Extension Builder (CS Extension Builder) afin de développer des extensions Creative
Suite dans ActionScript. Les extensions CS sont basées sur Flash (SWF) et peuvent potentiellement
fonctionner dans diverses applications Creative Suite.
Les applications CS possèdent une infrastructure qui permet aux développeurs d’étendre les capacités des
applications ; cette infrastructure est basée sur la technologie Flash/Flex et chaque extension CS est
fournie sous la forme d’un fichier Flash (SWF) compilé. CS comprend Extension Manager pour permettre
l’installation des extensions CS.
Adobe Kuler est un exemple d’extension CS fournie avec les produits. Adobe Kuler possède une interface
utilisateur homogène entre les différentes applications de la suite, mais dispose d’une logique différente,
adaptée à chaque application hôte.
L’interface utilisateur d’une extension est écrite en ActionScript, à l’aide de la structure Flex. Les extensions
CS sont généralement accessibles via leur propre élément de menu dans le menu Extensions de
l'application. CS Extension Builder vous permet de concevoir l’interface utilisateur de manière interactive à
l’aide du mode Création de FlashBuilder. Vous pouvez également développer l’intégralité de la logique
applicative de votre extension CS dans ActionScript ; de même que vous pouvez développer et déboguer
votre extension au sein de l’environnement familier de FlashBuilder.
Pour développer la logique d’application, nous vous recommandons d’utiliser la bibliothèque CSAWLib
(Creative Suite ActionScript Wrapper Library), qui applique le DOM de script de chaque application hôte
sous la forme d’une bibliothèque ActionScript. Ceci est étroitement intégré à l’environnement CS
Extension Builder, qui inclut des assistants afin de vous aider à créer la structure de base de l’extension,
puis à exécuter et à déboguer le code des applications de la suite, telles qu’Adobe InDesign, Photoshop et
Illustrator.
Les méthodes, les propriétés et le comportement du DOM de script sont décrits dans la référence de script
JavaScript de l’application hôte. Pour plus d’informations sur l’utilisation de CS Extension Builder et des
bibliothèques de wrappers, consultez la documentation du SDK Creative Suite, accessible depuis le
système d’aide de Flash Builder ou d’Eclipse, lorsque vous avez installé CS Extension Builder.
Utilisation des scripts de ce document
Pour utiliser n’importe quel script de ce document, ouvrez le fichier de script d’apprentissage (le nom de
fichier figure devant chaque script) ou copiez le code indiqué dans ce chapitre.
Les fichiers de script sont stockés dans une archive zip : InCopyCS6ScriptingGuideScripts.zip.
Au moment de décompresser l’archive, vous pouvez déplacer le dossier contenant les scripts créés dans
le langage de script que vous avez choisi d’utiliser (AppleScript, JavaScript ou VBScript) dans le dossier
Scripts Panel. Il est beaucoup plus aisé d’utiliser des fichiers de script que de saisir manuellement les
scripts ou de les copier-coller depuis ce document.
Si vous n’avez pas accès à l’archive des scripts, vous pouvez saisir le code de script indiqué dans ce
chapitre. Pour ce faire :
1. Copiez le script à partir de ce document Adobe PDF et collez-le dans l’utilitaire ExtendScript Toolkit.
Prise en main
Votre premier script InCopy
15
2. Enregistrez le script dans un fichier de texte brut dans le dossier Scripts Panel (voir la section
« Installation des scripts » à la page 12) avec l’extension appropriée : .jsx.
3. Choisissez la commande Fenêtre > Scripts pour afficher le panneau Scripts.
4. Pour exécuter le script, cliquez deux fois sur son nom dans le panneau Scripts.
La saisie manuelle de scripts ne fonctionne que pour les scripts présentés dans ce chapitre. Les scripts
présentés dans les autres chapitres sont seulement des extraits de script, pas des scripts entiers. Pour les
exécuter, vous devez utiliser les scripts contenus dans l’archive de scripts.
REMARQUE : si vous entrez les exemples manuellement (au lieu d’utiliser les scripts de l’archive de scripts),
il est très important d’utiliser la même casse que celle indiquée dans l’exemple. JavaScript est sensible
à la casse, et les scripts ne fonctionneront pas s’ils ne respectent pas la casse indiquée.
REMARQUE : si vous copiez et collez des scripts de ce document, soyez conscient que les sauts de ligne
provenant de la mise en page du document peuvent entraîner des erreurs dans vos scripts. Ces erreurs
pouvant être difficiles à repérer, il est recommandé d’utiliser les scripts dans l’archive zip.
Votre premier script InCopy
Nous allons maintenant créer un script InCopy pour générer un document, ajouter un bloc de texte et entrer
du texte dans ce bloc. Malgré son apparence simple, ce script permet d’effectuer les opérations suivantes :
X
Etablissement de la communication avec InCopy
X
Création d’un document
X
Ajout de texte à un article
Lancez l’utilitaire ExtendScript Toolkit (ou un éditeur de texte). Saisissez le script suivant (ou ouvrez le
script d’apprentissage HelloWorld.jsx) :
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
myStory.contents = "Hello World!";
Enregistrez le script dans un fichier de texte brut avec l’extension .jsx dans le dossier Scripts Panel (voir la
section « Installation des scripts » à la page 12). Pour exécuter le script, cliquez deux fois sur son nom dans
le panneau Scripts ou sélectionnez InCopy dans le menu déroulant cible de l’application, dans l’utilitaire
ExtendScript Toolkit, puis cliquez sur le bouton Exécuter.
Analyse du script
Cette section présente une analyse détaillée du script Hello World.
1. Etablissement de la communication avec l’objet d’application InCopy
L’application est désignée par le nom app.
2. Création d’un document et d’une référence au document
Var myDocument = app.documents.add();
3. Obtention d’une référence au premier article du document (un document autonome contient
toujours un article)
var myStory = myDocument.stories.item(0);
Prise en main
Terminologie des scripts et modèle d’objet InCopy 16
4. Ajout de texte à l’article en définissant la propriété de contenu sur une chaîne
myStory.contents = "Hello World!";
Terminologie des scripts et modèle d’objet InCopy
Maintenant que vous avez créé votre premier script InCopy, le moment est venu de vous familiariser avec
la terminologie des langages de script en général, et d’InCopy en particulier.
Terminologie des scripts
Passons tout d’abord en revue quelques termes et concepts utilisés couramment dans la création de
scripts.
Commentaires
Les commentaires permettent d’ajouter un descriptif à un script. Les commentaires sont ignorés pendant
l’exécution d’un script (ils ne génèrent donc aucune erreur). Ils permettent de documenter les opérations
d’un script (pour mémoire ou pour un autre développeur). Dans ce document, nous utilisons des
commentaires pour les scripts d’apprentissage.
Pour inclure un commentaire dans un script JavaScript, insérez // à gauche du commentaire ou placez le
commentaire entre /* et */. Par exemple :
// this is a comment
/* and so is this */
Valeurs
Le corps d’un caractère de texte, le contenu d’une remarque et le nom de fichier d’un document sont
autant d’exemple de valeurs utilisées pour la création de scripts InCopy. Les valeurs sont des données
utilisées par un script pendant son exécution.
Le type d’une valeur définit quelle sorte de donnée elle contient. Le type de valeur du contenu d’un mot,
par exemple, est une chaîne de texte. De même, le type de valeur de l’interligne d’un paragraphe est un
nombre. En général, les valeurs utilisées dans un script sont des nombres ou du texte. Le tableau ci-dessous
répertorie les types de valeurs les plus couramment utilisées pour la création de scripts InCopy.
Type de valeur
Nature
Exemple
Boolean
True ou False logique.
True
Integer
Nombres entiers (sans virgule).
Les entiers peuvent être positifs ou
négatifs.
14
Number
Nombre très précis pouvant être
décimal.
13.9972
Prise en main
Terminologie des scripts et modèle d’objet InCopy 17
Type de valeur
Nature
Exemple
String
Série de caractères de texte. Les
chaînes de texte sont présentées
entre guillemets anglais.
"I am a string"
Array
Liste de valeurs (ces valeurs
pouvant être de tout type).
["0p0", "0p0", "16p4", "20p6"]
Conversion de valeurs d’un type à un autre
Le langage JavaScript permet de convertir des valeurs variables d’un type à un autre. Parmi les conversions
les plus courantes, citons la conversion de nombres en chaînes de texte (ce qui permet d’entrer des
nombres comme texte ou de les afficher dans des boîtes de dialogue) ou la conversion de chaînes de texte
en nombres (ce qui permet de définir un corps ou une position de page).
//To convert from a number to a string:
myNumber = 2;
myString = myNumber + "";
//To convert from a string to an integer:
myString = "2";
myNumber = parseInt(myString);
//If your string contains a decimal value, use "parseFloat" rather than "parseInt":
myNumber = parseFloat(myString);
//You can also convert strings to numbers using the following:
myNumber = +myString;
Variables
Une variable est le conteneur d’une valeur. Les variables sont ainsi nommées car les valeurs qu’elles
contiennent peuvent changer. Une variable peut contenir un nombre, une chaîne de texte ou une
référence à un objet InCopy. Les variables portent un nom. Vous ferez donc référence à une variable par
son nom. Pour placer une valeur dans une variable, vous devez l’assigner à cette variable.
Dans tous les exemples de scripts et les scripts d’apprentissage accompagnant InCopy, les variables
commencent par my. Vous pouvez ainsi différencier facilement les variables créées dans un script des
termes du langage de script.
Affectation d’une valeur à une variable
L’affectation de valeurs ou de chaînes de texte à des variables est très simple, comme l’illustrent les
exemples suivants :
var myNumber = 10;
var myString = "Hello, World!";
var myTextFrame = myDocument.pages.item(0).textFrames.add();
REMARQUE : en JavaScript, toute variable non précédée de var est considérée par défaut comme globale,
non liée à une fonction spécifique. var n’est pas obligatoire, mais il est recommandé de l’utiliser dans les
scripts comprenant plusieurs fonctions.
Dans la mesure du possible, utilisez des noms évocateurs pour les variables, tels que firstPage ou
corporateLogo plutôt que x ou c, par exemple. Votre script sera beaucoup plus lisible. L’utilisation de
noms longs n’affecte en rien la vitesse d’exécution du script.
Prise en main
Terminologie des scripts et modèle d’objet InCopy 18
Les noms de variables doivent être composés d’un seul mot, mais vous pouvez utiliser les majuscules
(pour écrire myFirstPage, par exemple) ou les traits de soulignement (my_first_page) afin de les rendre
plus lisibles. Les noms de variables ne peuvent pas commencer par un chiffre, ni contenir des signes de
ponctuation ou des guillemets de citation anglais.
Variables de tableau de données
Un objet Array est un conteneur d’une série de valeurs :
myArray = [1, 2, 3, 4];
Pour faire référence à un élément d’un tableau de données, vous devez utiliser son numéro dans le
tableau. En JavaScript, le premier élément d’un tableau est l’élément 0 :
var myFirstArrayItem = myArray[0];
Un tableau de données peut en contenir un autre, comme dans les exemples ci-dessous :
var myArray = [[0,0], [72,72]];
Détermination du type de valeur d’une variable
Parfois, un script doit prendre des décisions en fonction du type de valeur d’un objet. Si vous travaillez sur
un script opérant sur une sélection de texte, par exemple, vous devrez peut-être définir l’arrêt du script si
aucune sélection n’est effectuée.
//Given a variable of unknown type, "myMysteryVariable"...
myType = myMysteryVariable.constructor.name;
//myType will be a string corresponding to the JavaScript type (e.g., "Rectangle")
Opérateurs
Les opérateurs utilisent des variables ou des valeurs pour exécuter des calculs (addition, soustraction,
multiplication et division) et renvoyer une valeur. Par exemple :
MyWidth/2
renvoie une valeur égale à la moitié du contenu de la variable myWidth.
Vous pouvez également utiliser des opérateurs pour effectuer des comparaisons (est égal à (=),
est différent de (<>), est supérieur à (>) ou est inférieur à (<)). Par exemple :
MyWidth > myHeight
renvoie la valeur « true » (ou 1) si myWidth est supérieur à myHeight, ou « false » (0) si ce n’est pas le cas.
Pour joindre deux chaînes de texte en JavaScript, utilisez le signe plus (+), comme suit :
"Pride " + "and Prejudice"
//returns the string: "Pride and Prejudice"
Instructions conditionnelles
« Si la taille du texte sélectionné est de 12 points, définissez le corps sur 10 points ». Il s’agit d’un exemple
d’instruction conditionnelle. Les instructions conditionnelles permettent au script d’évaluer des conditions
(telles que la couleur du texte sélectionné, le nombre de pages du document ou la date) et d’agir en
fonction du résultat. La plupart des instructions conditionnelles commencent par if.
Prise en main
Terminologie des scripts et modèle d’objet InCopy 19
Structures de contrôle
Si vous pouviez parler à InCopy, vous pourriez lui dire notamment « Répète vingt fois la procédure
suivante. ». En terminologie des scripts, cette instruction est appelée structure de contrôle. Les structures de
contrôle gèrent les processus répétitifs ou boucles. Une boucle répète une action continuellement, avec ou
sans changement entre les instances (ou itérations) de la boucle, jusqu’à ce qu’une condition spécifique
soit remplie. Les structures de contrôle commencent généralement par for.
Fonctions
Les fonctions sont des modules auxquels vous pouvez faire référence dans un script. Généralement, vous
envoyez une valeur ou une série de valeurs à une fonction et obtenez une ou plusieurs autres valeurs. Rien
de particulier à mentionner sur le code utilisé dans les fonctions (elles ont été créées pour vous éviter de
saisir les mêmes lignes de code de façon répétée dans un script). Les fonctions commencent par
function.
Présentation du modèle d’objet InDesign et InCopy
Lorsque vous pensez aux documents InCopy et InDesign, vous organisez certainement les programmes et
leurs composants dans votre esprit. Vous savez que les paragraphes sont contenus dans des blocs de texte
qui à leur tour apparaissent sur une page, qu’une page fait partie d’une planche, et que plusieurs planches
composent un document. Les documents contiennent des couleurs, des styles, des calques et des
planches types. Lorsque vous considérez les objets dans les documents que vous créez, vous pensez
intuitivement à leur ordre.
InDesign et InCopy « appréhendent » le contenu d’un document de la même manière. Un document
contient des pages, qui à leur tour contiennent des éléments de page (blocs de texte, rectangles, ellipses,
et ainsi de suite). Les blocs de texte contiennent des caractères, des mots, des paragraphes et des blocs
ancrés ; les blocs graphiques contiennent des images, des fichiers EPS ou des fichiers PDF ; les groupes
contiennent d’autres éléments de page. Tous ces éléments sont les objets qui composent une
publication InDesign, et qui sont utilisés pour écrire les scripts InDesign et InCopy.
Les objets de votre publication sont organisés dans un ordre spécifique : les paragraphes figurent à
l’intérieur d’un article, qui lui-même figure dans un document, qui à son tour figure à l’intérieur de l’objet
d’application InCopy. Les termes modèle d’objet et hiérarchie font référence à cette structure. Il est
impératif de posséder une bonne compréhension du modèle d’objet pour bien identifier l’objet que vous
souhaitez utiliser. Votre meilleur guide pour créer des scripts dans InCopy est votre connaissance de
l’application elle-même.
Les objets possèdent des propriétés (attributs). Par exemple, les propriétés d’un objet texte incluent la
police utilisée pour la mise en forme du texte, le corps et l’interligne appliqués au texte.
Les propriétés possèdent des valeurs. Ainsi, le corps des caractères du texte peut être représenté par un
nombre (en points) ou par la chaîne « Auto » pour l’interligne automatique. La propriété de couleur de
fond du texte peut être définie sur une couleur, un dégradé, une encre mélangée ou une nuance.
Les propriétés peuvent être en lecture/écriture ou en lecture seule. Vous pouvez définir les propriétés en
lecture/écriture sur d’autres valeurs, mais pas les propriétés en lecture seule.
Les objets possèdent également des méthodes. Les méthodes correspondent à des verbes de création de
scripts, aux actions qu’un objet peut effectuer. Par exemple, l’objet de document contient des méthodes
d’impression, d’exportation et d’enregistrement.
Les méthodes possèdent des paramètres ou des valeurs définissant l’effet de la méthode. La méthode
open, par exemple, possède un paramètre qui définit le fichier à ouvrir.
Prise en main
Terminologie des scripts et modèle d’objet InCopy 20
L’illustration suivante est une vue d’ensemble du modèle d’objet InCopy. Ce diagramme ne représente pas
la liste complète des objets disponibles dans les scripts InCopy. Il s’agit simplement d’une structure
conceptuelle permettant de comprendre la relation entre les types d’objets.
application
documents
a document
libraries
document preferences
books
document defaults
application preferences
document events
application defaults
document properties
application events
document methods
application menus
document elements
application properties
pages or spreads
application methods
page
stories
page items
text objects
Les objets figurant dans le diagramme sont expliqués dans le tableau suivant :
Terme
Signification
Application
InCopy
Application
defaults
Les paramètres par défaut de l’application, tels que les couleurs, les styles de paragraphe
et les styles d’objet. Les valeurs par défaut de l’application concernent tous les nouveaux
documents.
Application
events
Les événements qui se produisent à mesure qu’un utilisateur travaille dans l’application
ou qu’un script s’exécute. Les événements sont générés par l’ouverture, la fermeture
ou l’enregistrement d’un document ou par la sélection d’une commande de menu.
Les événements peuvent déclencher des scripts.
Application
menus
Les menus, sous-menus et menus contextuels qui s’affichent dans l’interface
utilisateur d’InCopy. Vous pouvez attacher des scripts aux menus pour exécuter des
commandes.
Application
methods
Les opérations que l’application peut effectuer, notamment rechercher et remplacer du
texte, copier la sélection, créer des documents ou ouvrir des bibliothèques.
Application
preferences
Par exemple, les préférences de texte, les préférences d’exportation PDF et les
préférences de document. De nombreux objets de préférences existent également
au niveau du document. Tout comme dans l’interface utilisateur, les préférences
d’application s’appliquent aux nouveaux documents ; les préférences de document
modifient les paramètres d’un document spécifique.
Prise en main
Terminologie des scripts et modèle d’objet InCopy 21
Terme
Signification
Application
properties
Les propriétés de l’application, notamment le chemin complet de l’application,
ses paramètres régionaux et le nom d’utilisateur.
Books
Une collection de livres ouverts.
Document
Un document InCopy.
Document
defaults
Les paramètres par défaut du document, tels que les couleurs, les styles de paragraphe
et les paramètres par défaut de mise en forme de texte.
Document
elements
Par exemple, les articles, les graphiques importés et les pages d’un document.
L’illustration ci-dessus indique des pages et des articles, car ces objets sont d’importants
conteneurs d’autres objets. Toutefois, les éléments de document incluent également des
rectangles, des ovales (ellipses), des groupes, des éléments XML, ainsi que tout autre
type d’objet que vous pouvez importer ou créer.
Document
events
Les événements qui se produisent au niveau du document, par exemple, l’importation
de texte (voir Application events plus haut dans le tableau).
Document
methods
Les opérations que le document peut effectuer, notamment fermer, imprimer ou
exporter un document.
Document
preferences
Les préférences d’un document, telles que les préférences de repères, d’affichage ou de
document.
Document
properties
Par exemple, le nom de fichier du document, le nombre de pages ou l’emplacement de
l’origine (point zéro).
Documents
Une collection de documents ouverts.
Libraries
Une collection de bibliothèques ouvertes.
Page
Une page dans un document InCopy.
Page item
Tout objet que vous pouvez créer ou placer sur une page. Il existe de nombreux types
d’éléments de page, tels que des blocs de texte, des rectangles, des lignes graphiques et
des groupes.
Pages or
spreads
Les pages ou les planches dans un document InCopy.
Stories
Le texte dans un document InCopy.
Text objects
Les caractères, mots, lignes, paragraphes et colonnes de texte sont des exemples
d’objets texte dans un article InCopy.
Consultation du modèle d’objet InCopy
Vous pouvez afficher le modèle d’objet InCopy à l’intérieur de votre application d’édition de scripts. Toutes
les informations de référence sur les objets et leurs propriétés et méthodes sont stockées dans le modèle
et peuvent être affichées.
Pour afficher le modèle d’objet InCopy dans l’utilitaire ExtendScript Toolkit :
1. Lancez l’utilitaire ExtendScript Toolkit.
2. Choisissez la commande Aide > InCopy CS6 Main Dictionary (Dictionnaire principal InCopy CS6).
L’utilitaire ExtendScript Toolkit charge le dictionnaire InCopy et l’affiche dans une fenêtre séparée.
Prise en main
Terminologie des scripts et modèle d’objet InCopy 22
3. Dans la liste des classes, sélectionnez l’objet que vous voulez afficher, puis cliquez sur la propriété ou la
méthode à détailler dans la liste des propriétés et méthodes. L’utilitaire ExtendScript Toolkit affiche
d’autres informations sur la propriété ou la méthode sélectionnée.
Pour plus de détails sur l’utilisation de l’outil de visualisation de modèle d’objet de l’utilitaire ExtendScript
Toolkit, voir le Guide des outils JavaScript Creative Suite 5.
Mesures et positionnement
Dans InCopy, tous les éléments et objets sont placés sur une page en fonction des mesures que vous
spécifiez. Il est donc très utile de connaître le fonctionnement du système de coordonnées d’InCopy et
les unités de mesure qu’il utilise.
Coordonnées
Comme tout autre programme de mise en page et de dessin, InCopy utilise une géométrie bidimensionnelle
simple pour définir la position des objets sur une page ou une planche. La composante horizontale d’une
paire de coordonnées est appelée x et sa composante verticale, y. Vous pouvez voir ces coordonnées dans le
panneau Transformation ou Contrôle lorsqu’un objet est sélectionné avec l’outil Sélection. Comme dans
l’interface utilisateur d’InCopy, les coordonnées sont mesurées par rapport à l’emplacement actuel de
l’origine (point zéro) de la règle.
Il existe une différence entre les coordonnées utilisées dans InCopy et le système de coordonnées
géométrique traditionnel. Sur l’axe vertical (ou y) d’InCopy, les coordonnées au-dessous de l’origine sont
des nombres positifs, et celles situées au-dessus, des nombres négatifs.
Prise en main
Ajout de caractéristiques à « Hello World » 23
Unités de mesure
Pour envoyer des valeurs de mesure à InCopy, vous pouvez utiliser soit des nombres (14.65, par exemple),
soit des chaînes de mesure (« 1p7.1 », par exemple). Si vous envoyez des nombres, InCopy utilise les unités
de mesure actives de la composition ; si vous envoyez des chaînes de mesure (voir le tableau ci-dessous),
InCopy utilise les unités de mesure spécifiées dans chaque chaîne.
InCopy renvoie les coordonnées et autres valeurs de mesure en utilisant les unités de mesure actives de la
composition. Dans certains cas, ces unités ne sont pas représentées sous la même forme que les valeurs de
mesure figurant dans le panneau Transformation d’InCopy. Si le système de mesure actif utilise les picas,
par exemple, InCopy renvoie des valeurs fractionnaires sous forme de nombres décimaux, au lieu d’utiliser
les conventions « picas et points » du panneau Transformation. Ainsi, « 1p6 » est renvoyé sous la forme
« 1.5 ». InCopy procède de cette manière, car le système de scripts ne peut pas exécuter d’opération
arithmétique avec des chaînes de mesure. Par exemple, si vous additionnez « 0p3.5 » et « 13p4 », vous allez
obtenir une erreur de script ; en revanche, si vous additionnez 0,2916 et 13,333 (les mêmes mesures après
leur conversion), le résultat sera correct.
Si votre script dépend de l’addition, la soustraction, la multiplication ou la division de valeurs de mesure
spécifiques, il est préférable de définir les unités de mesure correspondantes au début du script. A la fin du
script, vous pouvez rétablir les unités de mesure initialement utilisées avant l’exécution du script. Vous
pouvez également utiliser des remplacements d’unités de mesures, comme dans beaucoup de nos
exemples de scripts. Un remplacement d’unité de mesure est une chaîne contenant un caractère spécial,
comme dans les exemples ci-dessous.
Remplacement
Signification
Exemple
c
cicéros (le c peut être suivi de didots, si nécessaire)
1.4c
cm
centimètres
.635cm
i (or in)
pouces
.25i
mm
millimètres
6.35mm
p
picas (le p peut être suivi de points, si nécessaire)
1p6
pt
points
18pt
Ajout de caractéristiques à « Hello World »
Nous allons maintenant créer un script qui modifie la composition « Hello World » créée avec notre
premier script. Ce second script illustre les opérations suivantes :
X
Obtention du document actif
X
Changement de la mise en forme du texte dans son bloc
X
Ajout d’une note
Ouvrez le script d’apprentissage ImprovedHelloWorld ou procédez comme suit pour créer le script :
1.
Vérifiez que le document que vous avez créé précédemment est ouvert. Si vous avez fermé le document
sans l’enregistrer, il suffit de réexécuter le script HelloWorld.jsx pour créer un nouveau document.
Prise en main
Ajout de caractéristiques à « Hello World » 24
2. Entrez le code JavaScript ci-dessous dans un nouveau fichier texte.
//Get a reference to a font.
try{
//Enter the name of a font on your system, if necessary.
var myFont = app.fonts.item("Arial");
}
on(myError){}
//Get the active document and assign the result to the variable "myDocument"
var myDocument = app.documents.item(0);
with(myDocument.stories.item(0)){
//Change the font, size, and paragraph alignment.
try{
appliedFont = myFont;
}
on(myError){}
justification = Justification.centerAlign;
pointSize = 48;
//Enter the note at the last insertion point of the story.
var myNote = insertionPoints.item(-1).notes.add();
myNote.texts.item(0).contents = "This is a note."
}
3. Enregistrez le texte dans un fichier de texte brut avec l’extension .jsx dans le dossier Scripts Panel
(voir la section « Installation des scripts » à la page 12).
Pour exécuter le nouveau script, cliquez deux fois sur son nom dans le panneau Scripts.
3
Fonctions de scripts
Statut de mise à jour du chapitre
CS6
Modifié
« Versionnage des scripts » à la page 26 et ses trois sous-sections ont été mises à jour, corrigées et clarifiées.
Ce chapitre décrit les techniques de scripts en relation avec l’environnement de script InCopy. La
quasi-totalité des autres objets du modèle de scripts InCopy possèdent une fonction qui permet de
modifier les valeurs par défaut d’un document ou de l’application. En revanche, les fonctions décrites dans
ce chapitre commandent le fonctionnement des scripts.
Ce document aborde les thèmes suivants :
X
Objet scriptPreferences et ses propriétés
X
Référence au script d’exécution
X
Exécution des scripts dans les versions antérieures du modèle d’objet de script
X
Méthode doScript pour exécuter des scripts
X
Exécution des scripts au lancement d’InCopy
X
Contrôle du moteur ExtendScript dans lequel les scripts sont exécutés
Vous devez avoir préalablement lu le Chapitre 2, « Prise en main » et savoir créer, installer et exécuter les
scripts InCopy dans le langage de votre choix.
Préférences des scripts
L’objet scriptPreferences fournit les objets et les propriétés liés au mode d’exécution des scripts InCopy.
Le tableau suivant décrit plus en détail chaque propriété de l’objet scriptPreferences :
Propriété
Description
EnableRedraw
Active ou désactive la réactualisation de l’écran pendant l’exécution d’un
script dans le panneau Scripts.
scriptsFolder
Chemin d’accès au dossier des scripts.
scriptsList
Liste des scripts disponibles. Cette propriété représente un ensemble
d’éléments (tableau de données) sous la forme suivante :
[[fileName, filePath], …]
fileName correspond au nom du fichier de script et filePath au chemin
d’accès complet au script. Vous pouvez utiliser cette fonction pour vérifier
la présence d’un script dans l’ensemble des scripts installés.
25
Fonctions de scripts
Obtention du script en cours
Propriété
Description
userInteractionLevel
Cette propriété contrôle les alertes et les boîtes de dialogue d’InCopy
présentées à l’utilisateur. Lorsque vous paramétrez cette propriété sur
UserInteractionLevels.neverInteract, InCopy n’affiche pas d’alertes,
ni de boîtes de dialogue ; définissez-la sur
UserInteractionLevels.interactWithAlerts pour activer les alertes
mais désactiver les boîtes de dialogue, et sur interactWithAll pour
rétablir l’affichage normal des alertes et des boîtes de dialogue. La possibilité
de désactiver l’affichage des alertes est pratique lorsque vous ouvrez des
documents à l’aide d’un script ; souvent, InCopy affiche une alerte
correspondant à des polices ou des fichiers graphiques liés qui sont
manquants. Pour éviter cette alerte, définissez le niveau d’interaction
utilisateur sur UserInteractionLevels.neverInteract avant d’ouvrir le
document, puis rétablissez l’interaction utilisateur (en définissant la
propriété sur interactWithAll) avant d’exécuter le script.
version
Version de l’environnement de création de scripts en cours d’utilisation
(pour plus de détails, voir la section « Versionnage des scripts » à la
page 26). Notez que cette propriété diffère de la version de l’application.
26
Obtention du script en cours
Vous pouvez obtenir une référence au script en cours à l’aide de la propriété activeScript de l’objet
d’application. Vous pouvez utiliser cette propriété pour rechercher les fichiers et les dossiers relatifs au
script, comme l’illustre l’exemple suivant (dans le script d’apprentissage ActiveScript) :
var myScript = app.activeScript;
alert("The current script is: " + myScript);
var myParentFolder = File(myScript).parent;
alert("The folder containing the active script is: " + myParentFolder);
Lorsque vous déboguez des scripts à l’aide de l’éditeur de scripts, la propriété activeScript renvoie une
erreur. Seuls les scripts exécutés depuis la panneau Scripts figurent dans la propriété activeScript.
Lorsque vous déboguez des scripts avec l’utilitaire ExtendScript Toolkit, l’utilisation de la propriété
activeScript renvoie une erreur. Pour éviter cette erreur et mettre au point une méthode de débogage
des scripts qui utilisent la propriété activeScript, utilisez le gestionnaire d’erreurs suivant (dans le script
d’apprentissage GetScriptPath) :
function myGetScriptPath() {
try{
return app.activeScript;
}
catch(myError){
return File(myError.fileName);
}
}
Versionnage des scripts
InCopy peut exécuter des scripts utilisant des versions antérieures du modèle d’objet de script InCopy.
Pour exécuter un ancien script dans une version plus récente d’InCopy, vous devez prendre en compte les
points suivants :
X
Ciblage : les scripts doivent cibler la version d’InCopy dans laquelle ils sont exécutés (c’est-à-dire, la
version en cours). La méthode de ciblage dépend du langage, comme indiqué dans la section
« Ciblage » à la page 27.
Fonctions de scripts
Versionnage des scripts
27
X
Compilation : cette opération implique la mise en correspondance des noms dans le script avec les ID
de script sous-jacents qui sont interprétés par InCopy. La méthode de compilation dépend du
langage, comme indiqué dans la section « Compilation » à la page 27.
X
Interprétation : cette opération implique la mise en correspondance des ID avec le gestionnaire de
demande approprié dans InCopy. Ainsi, InCopy interprète correctement un script créé pour une
version antérieure du modèle d’objet de script. Pour cela, paramétrez explicitement les préférences de
script de l’application sur l’ancien modèle d’objet dans le script (comme indiqué dans la section
« Interprétation » à la page 27) ou exécutez le script à partir d’un dossier du dossier du panneau Scripts
comme suit :
Dossier
Version des scripts pour InCopy
Version 8.0 Scripts
CS6
Version 7.0 Scripts
CS5 et CS5.5
Version 6.0 Scripts
CS4
Version 5.0 Scripts
CS3
Version 2.0 Scripts
CS2
Ciblage
Un script doit toujours cibler la version d’InCopy dans laquelle il est exécuté (c’est-à-dire, la version en
cours), que ce soit de manière implicite ou explicite. Le ciblage est implicite lorsque le script est lancé
depuis le panneau Scripts.
Autrement, si le script est lancé en externe (à partir de l’ESTK), le ciblage explicite des scripts JavaScripts
est effectué à l’aide de l’instruction target :
//target CS6
#target "InCopy-8.0"
//target the latest version of InCopy
#target "InCopy"
Compilation
Les scripts JavaScript ne sont pas préalablement compilés. Pour la compilation, InCopy utilise la même
version du DOM que celle définie pour l’interprétation.
Interprétation
L’objet d’application InCopy comprend un objet scriptPreferences, permettant à un script d’obtenir ou
de définir la version du modèle d’objet de script à utiliser pour l’interprétation de scripts. La version par
défaut est la version actuelle de lapplication et persiste.
Par exemple, pour modifier la version du modèle d’objet de script en CS5 :
//Set to 7.0 scripting object model
app.scriptPreferences.version = 7.0;
Fonctions de scripts
Utilisation de la méthode doScript
28
Utilisation de la méthode doScript
La méthode doScript permet au script d’exécuter un autre script. Le script peut se présenter sous la forme
d’une chaîne de codes valides ou d’un fichier sur disque. Le script peut adopter le même langage de script
que le script courant ou un autre langage de script. Les langages disponibles varient d’une plate-forme à
une autre : sous Mac OS, vous pouvez exécuter un script AppleScript ou JavaScript ; sous Windows, vous
pouvez exécuter un script VBScript ou JavaScript.
La méthode doScript présente plusieurs utilisations possibles :
X
Exécution d’un script dans un autre langage qui fournit une fonction manquante dans votre langage
de script principal. Par exemple, VBScript n’offre pas la possibilité d’afficher un explorateur de fichiers
ou de dossiers, contrairement à JavaScript. AppleScript peut être très lent à calculer les fonctions
trigonométriques (sinus et cosinus), mais JavaScript effectue ces calculs rapidement. JavaScript ne
permet pas d’interroger Microsoft® Excel sur le contenu d’une cellule de feuille de calcul donnée,
mais AppleScript et VBScript proposent cette fonctionnalité. Dans tous ces exemples, la méthode
doScript peut exécuter un extrait de code de script dans un autre langage, pour contourner la
limitation du langage utilisé pour le corps du script.
X
Création d’un script « à la volée ». Votre script peut créer un script (sous la forme d’une chaîne) pendant
son exécution, qu’il peut ensuite exécuter à l’aide de la méthode doScript. C’est une méthode idéale
pour créer une boîte de dialogue ou un panneau personnalisé en fonction du contenu de la sélection ou
des attributs des objets que le script crée.
X
Incorporation des scripts dans les objets. Les scripts peuvent utiliser la méthode doScript pour exécuter
des scripts qui ont été enregistrés sous la forme de chaînes dans la propriété label des objets. Cette
technique permet à un objet de contenir un script qui contrôle ses propriétés de mise en page ou qui met
à jour son contenu en fonction de certains paramètres. Les scripts peuvent également être incorporés dans
des éléments XML sous la forme d’un attribut de l’élément ou du contenu d’un élément (voir la section
« Exécution des scripts au lancement » à la page 29).
Envoi de paramètres à l’objet doScript
Pour envoyer un paramètre à un script exécuté par l’objet doScript, utilisez la forme suivante (dans le
script d’apprentissage DoScriptParameters) :
var myParameters = ["Hello from DoScript", "Your message here."];
var myJavaScript = "alert(\"First argument: \" + arguments[0] + \"\\rSecond argument:
\" + arguments[1]);";
app.doScript(myJavaScript, ScriptLanguage.javascript, myParameters);
if(File.fs == "Windows"){
var myVBScript = "msgbox arguments(1), vbOKOnly, \"First argument: \" &
arguments(0)";
app.doScript(myVBScript, ScriptLanguage.visualBasic, myParameters);
}
else{
var myAppleScript = "tell application \"Adobe InCopy CS6\"\rdisplay dialog(\"First
argument: \" & item 1 of arguments & return & \"Second argument: \" & item 2 of
arguments)\rend tell";
app.doScript(myAppleScript, ScriptLanguage.applescriptLanguage, myParameters);
}
Fonctions de scripts
Exécution des scripts au lancement
29
Renvoi des valeurs de l’objet doScript
Pour renvoyer une valeur à partir d’un script exécuté par l’objet doScript, vous pouvez utiliser l’objet
scriptArgs (abréviation de « script arguments ») de l’application. L’extrait de script suivant explique
comment procéder (pour consulter le script complet, voir le script d’apprentissage DoScriptReturnValue) :
var myJavaScript = "app.scriptArgs.setValue(\"ScriptArgumentA\", \"This is the first
script argument value.\");\r";
myJavaScript += "app.scriptArgs.setValue(\"ScriptArgumentB\", \"This is the second
script argument value.\")";
var myScriptArgumentA = app.scriptArgs.getValue("ScriptArgumentA");
var myScriptArgumentB = app.scriptArgs.getValue("ScriptArgumentB");
alert("ScriptArgumentA: " + myScriptArgumentA + "\rScriptArgumentB: " +
myScriptArgumentB);
if(File.fs == "Windows"){
var myVBScript = "Set myInCopy = CreateObject(\"InCopy.Application\")\r";
myVBScript += "myInCopy.ScriptArgs.SetValue \"ScriptArgumentA\", \"This is the
first script argument value.\"\r";
myVBScript += "myInCopy.ScriptArgs.SetValue \"ScriptArgumentB\", \"This is the
second script argument value.\"";
app.doScript(myVBScript, ScriptLanguage.visualBasic);
}
else{
var myAppleScript = "tell application \"Adobe InCopy CS6\"\r";
myAppleScript += "make script arg with properties{name:\"ScriptArgumentA\",
value:\"This is the first script argument value.\"}\r";
myAppleScript += "make script arg with properties{name:\"ScriptArgumentB\",
value:\"This is the second script argument value.\"}\r";
myAppleScript += "end tell\r";
app.doScript(myAppleScript, ScriptLanguage.applescriptLanguage);
}
var myScriptArgumentA = app.scriptArgs.getValue("ScriptArgumentA");
var myScriptArgumentB = app.scriptArgs.getValue("ScriptArgumentB");
alert("ScriptArgumentA: " + myScriptArgumentA + "\rScriptArgumentB: " +
myScriptArgumentB);
Exécution des scripts au lancement
Pour exécuter un script au lancement d’InCopy, placez le script dans le dossier Startup Scripts du
dossier Scripts (pour plus de détails, voir la section « Installation des scripts » à la page 12).
REMARQUE : les scripts exécutés dans le moteur ExtendScript de la session au lancement d’InCopy peuvent
créer des objets et des fonctions qui seront accessibles par d’autres scripts pendant la durée de la session
(pour plus de détails, voir la section « Exécution de script par session et main » à la page 29).
Exécution de script par session et main
InCopy peut exécuter un script JavaScript de deux manières différentes : session et main. Ces noms
correspondent au « moteur » ExtendScript utilisé pour exécuter le script.
Par défaut, lorsque vous exécutez un script JavaScript InCopy, le script est interprété et exécuté par le
moteur ExtendScript « main », qui est supprimé lorsque l’exécution du script est terminée. Les objets de
script créés par le script ne sont alors plus valides.
Fonctions de scripts
Exécution de script par session et main
30
Les scripts exécutés dans le moteur session peuvent créer des objets qui sont valides jusqu’à la fermeture
de l’application InCopy. Vous pouvez faire référence à ces objets à partir d’autres scripts exécutés dans le
moteur session. Pour définir le moteur session comme cible d’un script JavaScript InCopy, ajoutez la
ligne suivante au début du script.
#targetengine "session"
Vous pouvez créer votre propre environnement d’interprétation et d’exécution ExtendScript valide. Pour
ce faire, utilisez l’instruction #targetenging, et indiquez le nom de votre moteur ExtendScript, comme
indiqué dans l’extrait de script suivant :
#targetengine "adobe"
4
Texte et saisie
Statut de mise à jour du chapitre
CS6
Inchangé
La saisie, l’édition et la mise en forme d’un texte représentent la majeure partie du temps consacré à la
plupart des documents InCopy. Ainsi, l’automatisation des opérations sur le texte, notamment la saisie,
peut représenter des gains de productivité importants.
Ce didacticiel décrit comment automatiser avec des scripts les opérations les plus courantes appliquées
au texte et à la saisie. Les exemples de scripts de ce chapitre sont présentés par ordre de complexité,
en commençant par des scripts très simples et en progressant vers des opérations plus complexes.
Vous devez avoir préalablement lu le Chapitre 2, « Prise en main » et savoir créer, installer et exécuter un
script. Vous devez également savoir manipuler le texte dans InCopy et connaître la terminologie de base
du domaine de la composition.
Saisie et importation de texte
Cette section décrit le processus d’insertion d’un texte dans les documents InCopy. Tout comme vous
pouvez saisir du texte dans des blocs de texte et importer des fichiers texte au moyen de l’interface
utilisateur InCopy, vous pouvez créer des blocs de texte, insérer du texte dans un article ou importer des
fichiers texte à l’aide de scripts.
Articles et blocs de texte
Tout le texte d’une mise en page InCopy fait partie d’un article, et chaque article peut contenir un ou
plusieurs blocs de texte. Si vous utilisez un document InCopy autonome, celui-ci contient un article, et
InCopy ajoute des blocs de texte uniquement si cela se révèle nécessaire pour afficher le texte de l’article.
Cela est valable également pour les articles exportés d’InDesign sous la forme d’articles InCopy
(fichiers .icml).
Lorsque vous utilisez un article InCopy dans un document InDesign, le document peut contenir un
nombre quelconque d’articles, et les blocs de texte s’affichent comme s’ils avaient été créés dans la mise
en page InDesign. Contrairement à InDesign, InCopy ne peut pas ajouter de nouveaux blocs de texte à
l’aide des scripts.
Pour plus de détails sur les relations entre les objets texte dans un document InCopy, voir la section
« Objets texte » à la page 40.
31
Texte et saisie
Saisie et importation de texte 32
Ajout d’un texte à un article
Pour ajouter du texte à un article, utilisez la propriété contents. L’exemple de script suivant utilise cette
technique pour ajouter du texte à la fin d’un article (pour consulter le script complet, voir AddText) :
var myDocument = app.documents.add();
//Add text to the default story.
var myStory = myDocument.stories.item(0);
myStory.contents = "This is the first paragraph of example text.";
//To add more text to the story, we'll use the last insertion point
//in the story. ("\r" is a return character in JavaScript.)
var myInsertionPoint = myStory.insertionPoints.item(-1);
myInsertionPoint.contents = "\rThis is the second paragraph.";
Remplacement de texte
Le script suivant remplace un mot par un groupe de mots, en changeant le contenu de l’objet approprié
(pour consulter le script complet, voir ReplaceWord) :
//Enters text in the default story and then replaces
//a word in the story with a different phrase.
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
myStory.contents = "This is some example text.";
//Replace the third word "some" with the phrase
//"a little bit of".
myStory.words.item(2).contents = "a little bit of";
Le script suivant remplace du texte dans un paragraphe (pour consulter le script complet, voir ReplaceText) :
//Enters text in the default story, and then replaces
//the text in the second paragraph.
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
myStory.contents = "Paragraph 1.\rParagraph 2.\rParagraph 3.\r";
//Replace the text in the second paragraph without replacing
//the return character at the end of the paragraph. To do this,
//we'll use the ItemByRange method.
var myStartCharacter = myStory.paragraphs.item(1).characters.item(0);
var myEndCharacter = myStory.paragraphs.item(1).characters.item(-2);
myStory.texts.itemByRange(myStartCharacter, myEndCharacter).contents = "This text
replaces the text in paragraph 2.";
Dans le script ci-dessus, nous avons utilisé la méthode itemByRange pour exclure le caractère du retour
chariot dans le second paragraphe, car si nous le supprimons, le style de paragraphe appliqué s’en trouve
modifié. Nous avons spécifié comme paramètres pour la méthode itemByRange deux caractères : les
caractères de début et de fin du paragraphe.
Texte et saisie
Importation de texte et définition des préférences d’importation de texte 33
Insertion de caractères spéciaux
Comme l’utilitaire ExtendScript Toolkit prend en charge Unicode, vous pouvez simplement entrer des
caractères Unicode dans des chaînes de caractères exportées dans InCopy. Vous pouvez également
utiliser la méthode JavaScript pour entrer directement des caractères Unicode par ID de glyphe : \unnnn
(nnnn étant le code Unicode du caractère). Le script suivant illustre plusieurs méthodes de saisie des
caractères spéciaux (pour consulter le script complet, voir SpecialCharacters) :
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
//Entering special characters directly.
myStory.contents = "Registered trademark: ®\rCopyright: ©\rTrademark: ™\r";
//Entering special characters by their Unicode glyph ID value:
myStory.insertionPoints.item(-1).contents = "Not equal to: \u2260\rSquare root:
\u221A\rParagraph: \u00B6\r";
//Entering InCopy special characters by their enumerations:
myStory.insertionPoints.item(-1).contents = "Automatic page number marker:";
myStory.insertionPoints.item(-1).contents = SpecialCharacters.autoPageNumber;
myStory.insertionPoints.item(-1).contents = "\r";
myStory.insertionPoints.item(-1).contents = "Section symbol:";
myStory.insertionPoints.item(-1).contents = SpecialCharacters.sectionSymbol;
myStory.insertionPoints.item(-1).contents = "\r";
myStory.insertionPoints.item(-1).contents = "En dash:";
myStory.insertionPoints.item(-1).contents = SpecialCharacters.enDash;
myStory.insertionPoints.item(-1).contents = "\r";
Le meilleur moyen pour rechercher l’ID Unicode d’un caractère est d’utiliser le panneau Glyphes
dans InCopy (choisissez la commande Texte > Glyphes pour afficher le panneau) ; il vous suffit de placer le
curseur sur un caractère dans le panneau pour qu’InCopy affiche sa valeur Unicode. Vous trouverez de plus
amples informations sur Unicode sur le site http://www.unicode.org.
Importation de texte et définition des préférences
d’importation de texte
Vous pouvez non seulement saisir des chaînes de caractères mais également importer des fichiers texte
créés dans des programmes de traitement de texte et des éditeurs de texte. Le script suivant indique
comment importer un fichier texte dans l’article par défaut d’un nouveau document (pour consulter le
script complet, voir PlaceTextFile) :
//Places a text file in the default story of a new document.
var myDocument = app.documents.add();
//Parameters for InsertionPoint.place():
//File as File object,
//[ShowingOptions as Boolean = False]
//You'll have to fill in your own file path.
myDocument.stories.item(0).insertionPoints.item(0).place(File("/c/test.txt"), false);
Pour définir les options d’importation du type de fichier texte à importer, utilisez l’objet de préférences
d’importation correspondant. Le script suivant montre comment définir les préférences d’importation de
texte (pour consulter le script complet, voir TextImportPreferences). Les commentaires du script
expliquent les différentes valeurs possibles pour chaque propriété.
//Sets the text import filter preferences.
with(app.textImportPreferences){
//Options for characterSet:
//TextImportCharacterSet.ansi
//TextImportCharacterSet.chineseBig5
//TextImportCharacterSet.gb18030
Texte et saisie
Importation de texte et définition des préférences d’importation de texte 34
//TextImportCharacterSet.gb2312
//TextImportCharacterSet.ksc5601
//TextImportCharacterSet.macintoshCE
//TextImportCharacterSet.macintoshCyrillic
//TextImportCharacterSet.macintoshGreek
//TextImportCharacterSet.macintoshTurkish
//TextImportCharacterSet.recommendShiftJIS83pv
//TextImportCharacterSet.shiftJIS90ms
//TextImportCharacterSet.shiftJIS90pv
//TextImportCharacterSet.utf8
//TextImportCharacterSet.utf16
//TextImportCharacterSet.windowsBaltic
//TextImportCharacterSet.windowsCE
//TextImportCharacterSet.windowsCyrillic
//TextImportCharacterSet.windowsEE
//TextImportCharacterSet.windowsGreek
//TextImportCharacterSet.windowsTurkish
characterSet = TextImportCharacterSet.utf16;
convertSpacesIntoTabs = true;
spacesIntoTabsCount = 3;
//The dictionary property can take any of the following
//language names (as strings):
//Bulgarian
//Catalan
//Croatian
//Czech
//Danish
//Dutch
//English: Canadian
//English: UK
//English: USA
//English: USA Legal
//English: USA Medical
//Estonian
//Finnish
//French
//French: Canadian
//German: Reformed
//German: Swiss
//German: Traditional
//Greek
//Hungarian
//Italian
//Latvian
//Lithuanian
//Neutral
//Norwegian: Bokmal
//Norwegian: Nynorsk
//Polish
//Portuguese
//Portuguese: Brazilian
//Romanian
//Russian
//Slovak
//Slovenian
//Spanish: Castilian
//Swedish
//Turkish
dictionary = "English: USA";
//platform options:
Texte et saisie
Importation de texte et définition des préférences d’importation de texte 35
//ImportPlatform.macintosh
//ImportPlatform.pc
platform = ImportPlatform.macintosh;
stripReturnsBetweenLines = true;
stripReturnsBetweenParagraphs = true;
useTypographersQuotes = true;
}
Le script suivant montre comment définir les préférences d’importation de texte référencé (pour consulter
le script complet, voir TaggedTextImportPreferences) :
//Sets the tagged text import filter preferences.
with(app.taggedTextImportPreferences){
removeTextFormatting = false;
//styleConflict property can be:
//StyleConflict.publicationDefinition
//StyleConflict.tagFileDefinition
styleConflict = StyleConflict.publicationDefinition;
useTypographersQuotes = true;
}
Le script suivant montre comment définir les préférences d’importation au format Word et RTF
(pour consulter le script complet, voir WordRTFImportPreferences) :
//Sets the Word/RTF import filter preferences.
with(app.wordRTFImportPreferences){
//convertPageBreaks property can be:
//ConvertPageBreaks.columnBreak
//ConvertPageBreaks.none
//ConvertPageBreaks.pageBreak
convertPageBreaks = ConvertPageBreaks.none;
//convertTablesTo property can be:
//ConvertTablesOptions.unformattedTabbedText
//ConvertTablesOptions.unformattedTable
convertTablesTo = ConvertTablesOptions.unformattedTable;
importEndnotes = true;
importFootnotes = true;
importIndex = true;
importTOC = true;
importUnusedStyles = false;
preserveGraphics = false;
preserveLocalOverrides = false;
preserveTrackChanges = false;
removeFormatting = false;
//resolveCharacterSytleClash and resolveParagraphStyleClash properties can be:
//ResolveStyleClash.resolveClashAutoRename
//ResolveStyleClash.resolveClashUseExisting
//ResolveStyleClash.resolveClashUseNew
resolveCharacterStyleClash = ResolveStyleClash.resolveClashUseExisting;
resolveParagraphStyleClash = ResolveStyleClash.resolveClashUseExisting;
useTypographersQuotes = true;
}
Texte et saisie
Exportation de texte et définition des préférences d’exportation de texte 36
Le script suivant montre comment définir les préférences d’importation au format Excel (pour consulter le
script complet, voir ExcelImportPreferences) :
//Sets the Excel import filter preferences.
with(app.excelImportPreferences){
//alignmentStyle property can be:
//AlignmentStyleOptions.centerAlign
//AlignmentStyleOptions.leftAlign
//AlignmentStyleOptions.rightAlign
//AlignmentStyleOptions.spreadsheet
alignmentStyle = AlignmentStyleOptions.spreadsheet;
decimalPlaces = 4;
preserveGraphics = false;
//Enter the range you want to import as "start cell:end cell".
rangeName = "A1:B16";
sheetIndex = 1;
//You'll have to enter a valid worksheet name.
sheetName = "pathpoints";
showHiddenCells = false;
//tableFormatting property can be:
//TableFormattingOptions.excelFormattedTable
//TableFormattingOptions.excelUnformattedTabbedText
//TableFormattingOptions.excelUnformattedTable
tableFormatting = TableFormattingOptions.excelFormattedTable;
useTypographersQuotes = true;
viewName = "";
}
Exportation de texte et définition des préférences
d’exportation de texte
Le script suivant indique comment exporter du texte à partir d’un document InCopy. Vous devez utiliser
des objets texte ou article pour exporter un contenu dans des formats de fichier texte ; vous ne pouvez pas
exporter tout le texte d’un document en une seule opération. (Pour consulter le script complet,
voir ExportTextFile.)
//Creates a story in an example document and then exports the text to a text file.
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
//Fill the story with placeholder text.
var myTextFrame = myStory.textContainers[0];
myTextFrame.contents = TextFrameContents.placeholderText;
//Text exportFile method parameters:
//Format as ExportFormat
//To As File
//[ShowingOptions As Boolean = False]
//
//Format parameter can be:
//ExportFormat.inCopyCSDocument
//ExportFormat.inCopyDocument
//ExportFormat.rtf
//ExportFormat.taggedText
//ExportFormat.textType
//
//Export the story as text. You'll have to fill in a valid file path on your system.
myStory.exportFile(ExportFormat.textType, File("/c/test.txt"));
Texte et saisie
Exportation de texte et définition des préférences d’exportation de texte 37
L’exemple suivant indique comment exporter une plage de texte spécifique. (Nous avons omis la fonction
myGetBounds dans cette liste ; voir le script d’apprentissage ExportTextRange.)
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
//Fill the story with placeholder text.
var myTextFrame = myStory.textContainers[0];
myTextFrame.contents = TextFrameContents.placeholderText;
var myStartCharacter = myStory.paragraphs.item(0).characters.item(0);
var myEndCharacter = myStory.paragraphs.item(1).characters.item(-1);
var myText = myStory.texts.itemByRange(myStartCharacter, myEndCharacter);
//Text exportFile method parameters:
//Format as ExportFormat
//To As File
//[ShowingOptions As Boolean = False]
//
//Format parameter can be:
//ExportFormat.inCopyCSDocument
//ExportFormat.inCopyDocument
//ExportFormat.rtf
//ExportFormat.taggedText
//ExportFormat.textType
//
//Export the text range. You must fill in a valid file path on your system.
myText.exportFile(ExportFormat.textType, File("/c/test.txt"));
Pour définir les options d’exportation du type de fichier texte à exporter, utilisez l’objet de préférences
d’exportation correspondant. Le script suivant permet de définir les préférences d’exportation d’un texte
(pour consulter le script complet, voir TextExportPreferences) :
//Sets the text export filter preferences.
with(app.textExportPreferences){
//Options for characterSet:
//TextExportCharacterSet.utf8
//TextExportCharacterSet.utf16
//TextExportCharacterSet.defaultPlatform
characterSet = TextExportCharacterSet.utf16;
//platform options:
//ImportPlatform.macintosh
//ImportPlatform.pc
platform = ImportPlatform.macintosh;
}
Le script suivant permet de définir les préférences d’exportation d’un texte référencé (pour consulter le
script complet, voir TaggedTextExportPreferences) :
//Sets the tagged text export filter preferences.
with(app.taggedTextExportPreferences){
//Options for characterSet:
//TagTextExportCharacterSet.ansi
//TagTextExportCharacterSet.ascii
//TagTextExportCharacterSet.gb18030
//TagTextExportCharacterSet.ksc5601
//TagTextExportCharacterSet.shiftJIS
//TagTextExportCharacterSet.utf8
//TagTextExportCharacterSet.utf16
characterSet = TagTextExportCharacterSet.utf16;
Texte et saisie
Exportation de texte et définition des préférences d’exportation de texte 38
//tagForm options:
//TagTextForm.abbreviated
//TagTextForm.verbose
tagForm = TagTextForm.verbose;
}
Sachez que l’exportation de texte n’est pas limitée aux filtres d’exportation existants. Etant donné que
JavaScript peut enregistrer des fichiers texte sur disque, vous pouvez créer un script qui analyse le texte
d’un document et l’exporte dans l’ordre de votre choix, à l’aide d’un modèle de balisage de texte qui vous
convient. Voici un exemple très simple qui montre comment exporter du texte InCopy au format HTML
(pour consulter le script complet, voir ExportHTML) :
function myExportHTML(){
var myStory, myParagraph, myString, myTag, myStartTag, myEndTag,
myTextStyleRange, myTable;
//Use the myStyleToTagMapping array to set up your paragraph style to tag mapping.
var myStyleToTagMapping = new Array;
//For each style to tag mapping, add a new item to the array.
myStyleToTagMapping.push(["body_text", "p"]);
myStyleToTagMapping.push(["heading1", "h1"]);
myStyleToTagMapping.push(["heading2", "h2"]);
myStyleToTagMapping.push(["heading3", "h3"]);
//End of style to tag mapping.
if(app.documents.length !=0){
if(app.documents.item(0).stories.length != 0){
//Open a new text file.
var myTextFile = File.saveDialog("Save HTML As", undefined);
//If the user clicked the Cancel button, the result is null.
if(myTextFile != null){
//Open the file with write access.
myTextFile.open("w");
//Iterate through the stories.
for(var myCounter = 0; myCounter <
app.documents.item(0).stories.length; myCounter ++){
myStory = app.documents.item(0).stories.item(myCounter);
for(var myParagraphCounter = 0; myParagraphCounter <
myStory.paragraphs.length; myParagraphCounter ++){
myParagraph = myStory.paragraphs.item(myParagraphCounter);
if(myParagraph.tables.length == 0){
if(myParagraph.textStyleRanges.length == 1){
//If the paragraph is a simple paragraph--no tables,
//no local formatting--simply export the text
//of the pararaph with the appropriate tag.
myTag = myFindTag(myParagraph.appliedParagraphStyle.
name, myStyleToTagMapping);
//If the tag comes back empty,
//map it to the basic paragraph tag.
if(myTag == ""){
myTag = "p";
}
myStartTag = "<" + myTag + ">";
myEndTag = "</" + myTag + ">";
//If the paragraph is not the last paragraph in the
//story, omit the return character.
if(myParagraph.characters.item(-1).contents == "\r"){
myString = myParagraph.texts.itemByRange
(myParagraph.characters.item(0),
myParagraph.characters.item(-2)).contents;
}
else{
Texte et saisie
Exportation de texte et définition des préférences d’exportation de texte 39
myString = myParagraph.contents;
}
//Write the paragraphs' text to the text file.
myTextFile.writeln(myStartTag + myString + myEndTag);
}
else{
//Handle text style range export by iterating
//through the text style ranges in the paragraph.
for(var myRangeCounter = 0; myRangeCounter <
myParagraph.textStyleRanges.length;
myRangeCounter ++){
myTextStyleRange = myParagraph.textStyleRanges.
item(myRangeCounter);
if(myTextStyleRange.characters.item(-1)=="\r"){
myString = myTextStyleRange.texts.itemByRange
(myTextStyleRange.characters.item(1),
myTextStyleRange.characters.item(-2)).
contents;
}
else{
myString = myTextStyleRange.contents;
}
switch(myTextStyleRange.fontStyle){
case "Bold":
myString = "<b>" + myString + "</b>"
break;
case "Italic":
myString = "<i>" + myString + "</i>"
break;
}
myTextFile.write(myString);
}
myTextFile.write("\r");
}
}
else{
//Handle table export (assumes that there is only
//one table per paragraph,and that the table is in the
//paragraph by itself).
myTable = myParagraph.tables.item(0);
myTextFile.writeln("<table border = 1>");
for(var myRowCounter = 0; myRowCounter <
myTable.rows.length; myRowCounter ++){
myTextFile.writeln("<tr>");
for(var myColumnCounter = 0; myColumnCounter <
myTable.columns.length; myColumnCounter++){
if(myRowCounter == 0){
myString = "<th>" + myTable.rows.item
(myRowCounter).cells.item(myColumnCounter).
texts.item(0).contents + "</th>";
}
else{
myString = "<td>" + myTable.rows.item
(myRowCounter).cells.item(myColumnCounter).
texts.item(0).contents + "</td>";
}
myTextFile.writeln(myString);
}
myTextFile.writeln("</tr>");
}
Texte et saisie
Objets texte 40
myTextFile.writeln("</table>");
}
}
}
//Close the text file.
myTextFile.close();
}
}
}
}
function myFindTag (myStyleName, myStyleToTagMapping){
var myTag = "";
var myDone = false;
var myCounter = 0;
do{
if(myStyleToTagMapping[myCounter][0] == myStyleName){
myTag = myStyleToTagMapping[myCounter][1];
break;
}
myCounter ++;
} while((myDone == false)||(myCounter < myStyleToTagMapping.length))
return myTag;
}
Objets texte
Le diagramme suivant illustre une vue du modèle d’objet texte InCopy. Il existe deux types d’objet texte
principaux : les objets layout (blocs de texte) et les objets text-stream (articles, points d’insertion, caractères
et mots, par exemple). Le diagramme utilise les termes en langage naturel pour les objets ; lorsque vous
créez des scripts, vous utilisez les termes correspondants de votre langage de script :
document
story
spread, page, layer
insertion points
characters
text containers
text frame
words
insertion points
lines
characters
paragraphs
words
text columns
lines
text style ranges
paragraphs
texts
text columns
notes
text style ranges
texts
notes
Texte et saisie
Objets texte 41
Pour tout objet text-stream, le parent de l’objet est l’article contenant l’objet. Pour obtenir une référence
au bloc de texte (ou aux blocs de texte) contenant un objet texte donné, utilisez la propriété
parentTextFrames.
Pour un bloc de texte, le parent du bloc de texte est généralement la page ou la planche contenant le bloc
de texte. Si le bloc de texte se trouve à l’intérieur d’un groupe ou a été collé à l’intérieur d’un autre élément
de page, le parent du bloc de texte est l’élément de page qui le contient. Si le bloc de texte a été converti
en bloc ancré, le parent du bloc de texte est le caractère contenant le bloc ancré.
Sélections
Généralement, les scripts InCopy agissent sur une sélection de texte. Le script suivant permet de
déterminer le type de la sélection en cours. Contrairement à de nombreux autres exemples de scripts,
ce script n’effectue aucune opération en particulier ; il présente simplement une routine de filtrage de
la sélection que vous pouvez utiliser dans vos propres scripts. (Pour consulter le script complet,
voir TextSelection.)
//Shows how to determine whether the current selection is a text selection.
//Check to see if any documents are open.
if (app.documents.length != 0){
//If the selection contains more than one item, the selection
//is not text selected with the Type tool.
if (app.selection.length != 0){
//Evaluate the selection based on its type.
switch (app.selection[0].constructor.name){
case "InsertionPoint":
case "Character":
case "Word":
case "TextStyleRange":
case "Line":
case "Paragraph":
case "TextColumn":
case "Text":
case "Story":
//The object is a text object; display the text object type.
//A practical script would do something with the selection,
//or pass the selection on to a function.
alert("Selection is a " + app.selection[0].constructor.name);
//If the selection is inside a note, the parent of the selection
//will be a note object.
if(app.selection[0].parent.constructor.name == "Note"){
alert("Selection is inside a note.");
}
break;
default:
alert("The selected object is not a text object. Select some text and try
again.");
break;
}
}
else{
alert("Please select some text and try again.");
}
}
else{
alert("No documents are open.");
}
Texte et saisie
Objets texte 42
Déplacement et copie de texte
Pour déplacer un objet texte dans le texte, utilisez la méthode move. Pour copier le texte, utilisez la
méthode duplicate (qui possède exactement les mêmes paramètres que la méthode move). L’extrait de
script suivant illustre son mode d’utilisation (pour consulter le script complet, voir MoveText) :
//Create an example document.
var myDocument = app.documents.add();
//Create a series of paragraphs in the default story.
var myStory = myDocument.stories.item(0);
myStory.contents = "WordA\rWordB\rWordC\rWordD\r";
//Move WordC before WordA.
myStory.paragraphs.item(2).move(LocationOptions.before, myStory.paragraphs.item(0));
//Move WordB after WordD (into the same paragraph).
myStory.paragraphs.item(2).move(LocationOptions.after,
myStory.paragraphs.item(-1).words.item(0));
//Note that moving text removes it from its original location.
Vous pouvez également utiliser la méthode move pour transférer un texte mis en forme entre deux
documents. Le recours à la méthode move ou duplicate est préférable à l’utilisation de la méthode
copier-coller pour laquelle vous devez rendre le document visible et sélectionner le texte à copier. Les
méthodes move et duplicate sont plus rapides et plus performantes. Le script suivant permet de déplacer
du texte d’un document à l’autre à l’aide des méthodes move et duplicate (pour consulter le script
complet, voir MoveTextBetweenDocuments) :
//Moves formatted text from one document to another.
var mySourceDocument = app.documents.add();
//Add text to the default story.
var mySourceStory = mySourceDocument.stories.item(0);
mySourceStory.contents = "This is the source text.\rThis text is not the source text.";
mySourceStory.paragraphs.item(0).pointSize = 24;
//Create a new document to move the text to.
var myTargetDocument = app.documents.add();
var myTargetStory = myTargetDocument.stories.item(0);
myTargetStory.contents = "This is the target text. Insert the source text after this
paragraph.\r";
mySourceStory.paragraphs.item(0).duplicate(LocationOptions.after,
myTargetStory.insertionPoints.item(-1));
Pour copier du texte sans mise en forme entre deux objets texte, vous pouvez également utiliser la
propriété contents d’un objet texte et définir la propriété contents d’un autre objet texte à l’aide de
cette chaîne. Le script suivant illustre la façon de procéder (pour consulter le script complet,
voir CopyUnformattedText) :
//Shows how to remove formatting from text as you move it
//to other locations in a document.
//Create an example document.
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
myStory.contents = "This is a formatted string.\rText pasted after this text will
retain its formatting.\r\rText moved to the following line will take on the formatting
of the insertion point.\rItalic: ";
//Apply formatting to the first paragraph.
myStory.paragraphs.item(0).fontStyle = "Bold";
//Apply formatting to the last paragraph.
myStory.paragraphs.item(-1).fontStyle = "Italic";
//Copy from one frame to another using a simple copy.
app.select(myStory.paragraphs.item(0).words.item(0));
app.copy();
app.select(myStory.paragraphs.item(1).insertionPoints.item(-1));
Texte et saisie
Objets texte 43
app.paste();
//Copy the unformatted string from the first word to the end of the story
//by getting and setting the contents of text objects. Note that this does
//not really copy the text; it replicates the text string from one text
//location to another.
myStory.insertionPoints.item(-1).contents =
myStory.paragraphs.item(0).words.item(0).contents;
Objets texte et itération
Lorsque votre script déplace, supprime ou ajoute du texte pendant une itération dans une série d’objets
texte, vous pouvez facilement vous retrouver avec des références de texte incorrectes. Le script suivant
illustre ce problème (pour consulter le script complet, voir TextIterationWrong) :
//Shows how *not* to iterate through text.
var myDocument = app.documents.add();
var myString = "Paragraph 1.\rDelete this paragraph.\rParagraph 2.\rParagraph
3.\rParagraph 4.\rParagraph 5.\rDelete this paragraph.\rParagraph 6.\r";
var myStory = myDocument.stories.item(0);
myStory.contents = myString;
//The following for loop will fail to format all of the paragraphs.
for(var myParagraphCounter = 0; myParagraphCounter < myStory.paragraphs.length;
myParagraphCounter ++){
if(myStory.paragraphs.item(myParagraphCounter).words.item(0).contents ==
"Delete"){
myStory.paragraphs.item(myParagraphCounter).remove();
}
else{
myStory.paragraphs.item(myParagraphCounter).pointSize = 24;
}
}
Dans l’exemple précédent, certains paragraphes ne sont pas mis en forme. Pourquoi ? La boucle du script
balaye les paragraphes à partir du premier paragraphe de l’article jusqu’au dernier. Pendant cette
opération, les paragraphes commençant par « Delete » sont supprimés. Lorsque le script supprime le
deuxième paragraphe, le troisième paragraphe remonte dans la liste et prend sa place. Lorsque le
compteur affiche 2, le script traite le paragraphe qui correspondait au quatrième paragraphe dans
l’article ; le troisième paragraphe d’origine devient le deuxième paragraphe et est ignoré.
Pour éviter ce problème, effectuez une itération inverse dans les objets texte, comme l’illustre le script
suivant (dans le script d’apprentissage TextIterationRight) :
//Shows the correct way to iterate through text.
var myDocument = app.documents.add();
var myString = "Paragraph 1.\rDelete this paragraph.\rParagraph 2.\rParagraph
3.\rParagraph 4.\rParagraph 5.\rDelete this paragraph.\rParagraph 6.\r";
var myStory = myDocument.stories.item(0);
myStory.contents = myString;
//The following for loop will format all of the paragraphs by iterating
//backwards through the paragraphs in the story.
for(var myParagraphCounter = myStory.paragraphs.length-1; myParagraphCounter >= 0;
myParagraphCounter --){
if(myStory.paragraphs.item(myParagraphCounter).words.item(0).contents ==
"Delete"){
myStory.paragraphs.item(myParagraphCounter).remove();
}
else{
myStory.paragraphs.item(myParagraphCounter).pointSize = 24;
}
}
Texte et saisie
Mise en forme du texte 44
Mise en forme du texte
Dans les sections précédentes de ce chapitre, nous avons ajouté du texte à un document et utilisé des
articles et des objets texte. Dans cette section, nous allons appliquer une mise en forme au texte. Toutes
les fonctions de composition InCopy sont prises en charge par les scripts.
Définition des valeurs par défaut du texte
Vous pouvez définir des valeurs de texte par défaut à la fois pour l’application et chaque document.
Les valeurs de texte par défaut pour l’application déterminent celles de tous les nouveaux documents.
Les valeurs de texte par défaut d’un document définissent la mise en forme de tous les nouveaux objets
texte de ce document. (Pour consulter le script complet, voir TextDefaults.)
//Sets the text defaults of the application, which set the default formatting
//for all new documents. Existing text frames are unaffected.
//Set the measurement units to points.
app.viewPreferences.horizontalMeasurementUnits = MeasurementUnits.points;
app.viewPreferences.verticalMeasurementUnits = MeasurementUnits.points;
//To set the text formatting defaults for a document, replace "app"
//in the following lines with a reference to a document.
with(app.textDefaults){
alignToBaseline = true;
//Because the font might not be available, it's usually best
//to apply the font within a try...catch structure. Fill in the
//name of a font on your system.
try{
appliedFont = app.fonts.item("Minion Pro");
}
catch(e){}
//Because the font style might not be available, it's usually best
//to apply the font style within a try...catch structure.
try{
fontStyle = "Regular";
}
catch(e){}
//Because the language might not be available, it's usually best
//to apply the language within a try...catch structure.
try{
appliedLanguage = "English: USA";
}
catch(e){}
autoLeading = 100;
balanceRaggedLines = false;
baselineShift = 0;
capitalization = Capitalization.normal;
composer = "Adobe Paragraph Composer";
desiredGlyphScaling = 100;
desiredLetterSpacing = 0;
desiredWordSpacing = 100;
dropCapCharacters = 0;
if(dropCapCharacters != 0){
dropCapLines = 3;
//Assumes the application has a default character style named "myDropCap"
dropCapStyle = app.characterStyles.item("myDropCap");
}
fillColor = app.colors.item("Black");
fillTint = 100;
firstLineIndent = 14;
Texte et saisie
Mise en forme du texte 45
gridAlignFirstLineOnly = false;
horizontalScale = 100;
hyphenateAfterFirst = 3;
hyphenateBeforeLast = 4;
hyphenateCapitalizedWords = false;
hyphenateLadderLimit = 1;
hyphenateWordsLongerThan = 5;
hyphenation = true;
hyphenationZone = 36;
hyphenWeight = 9;
justification = Justification.leftAlign;
keepAllLinesTogether = false;
keepLinesTogether = true;
keepFirstLines = 2;
keepLastLines = 2;
keepWithNext = 0;
kerningMethod = "Optical";
kerningValue = 0;
leading = 14;
leftIndent = 0;
ligatures = true;
maximumGlyphScaling = 100;
maximumLetterSpacing = 0;
maximumWordSpacing = 160;
minimumGlyphScaling = 100;
minimumLetterSpacing = 0;
minimumWordSpacing = 80;
noBreak = false;
otfContextualAlternate = true;
otfDiscretionaryLigature = false;
otfFigureStyle = OTFFigureStyle.proportionalOldstyle;
otfFraction = true;
otfHistorical = false;
otfOrdinal = false;
otfSlashedZero = false;
otfSwash = false;
otfTitling = false;
overprintFill = false;
overprintStroke = false;
pointSize = 11;
position = Position.normal;
rightIndent = 0;
ruleAbove = false;
if(ruleAbove == true){
ruleAboveColor = app.colors.item("Black");
ruleAboveGapColor = app.swatches.item("None");
ruleAboveGapOverprint = false;
ruleAboveGapTint = 100;
ruleAboveLeftIndent = 0;
ruleAboveLineWeight = .25;
ruleAboveOffset = 14;
ruleAboveOverprint = false;
ruleAboveRightIndent = 0;
ruleAboveTint = 100;
ruleAboveType = app.strokeStyles.item("Solid");
ruleAboveWidth = RuleWidth.columnWidth;
}
ruleBelow = false;
if(ruleBelow == true){
ruleBelowColor = app.colors.item("Black");
Texte et saisie
Mise en forme du texte 46
ruleBelowGapColor = app.swatches.item("None");
ruleBelowGapOverprint = false;
ruleBelowGapTint = 100;
ruleBelowLeftIndent = 0;
ruleBelowLineWeight = .25;
ruleBelowOffset = 0;
ruleBelowOverprint = false;
ruleBelowRightIndent = 0;
ruleBelowTint = 100;
ruleBelowType = app.strokeStyles.item("Solid");
ruleBelowWidth = RuleWidth.columnWidth;
}
singleWordJustification = SingleWordJustification.leftAlign;
skew = 0;
spaceAfter = 0;
spaceBefore = 0;
startParagraph = StartParagraph.anywhere;
strikeThru = false;
if(strikeThru == true){
strikeThroughColor = app.colors.item("Black");
strikeThroughGapColor = app.swatches.item("None");
strikeThroughGapOverprint = false;
strikeThroughGapTint = 100;
strikeThroughOffset = 3;
strikeThroughOverprint = false;
strikeThroughTint = 100;
strikeThroughType = app.strokeStyles.item("Solid");
strikeThroughWeight = .25;
}
strokeColor = app.swatches.item("None");
strokeTint = 100;
strokeWeight = 0;
tracking = 0;
underline = false;
if(underline == true){
underlineColor = app.colors.item("Black");
underlineGapColor = app.swatches.item("None");
underlineGapOverprint = false;
underlineGapTint = 100;
underlineOffset = 3;
underlineOverprint = false;
underlineTint = 100;
underlineType = app.strokeStyles.item("Solid");
underlineWeight = .25
}
verticalScale = 100;
}
Texte et saisie
Mise en forme du texte 47
Polices
La collection des polices d’un objet d’application InCopy contient toutes les polices accessibles à InCopy.
En revanche, la collection des polices d’un document ne contient que les polices utilisées dans le document.
La collection des polices d’un document contient également les polices manquantes (polices utilisées dans le
document qui ne sont pas accessibles à InCopy). Le script suivant illustre la différence entre les polices de
l’application et celles du document (pour consulter le script complet, voir FontCollections) :
//Shows the difference between the fonts collection of the application
//and the fonts collection of a document.
var myApplicationFonts = app.fonts;
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
var myDocumentFonts = myDocument.fonts;
var myFontNames = myApplicationFonts.everyItem().name;
if(myDocumentFonts.length > 0){
var myDocumentFontNames = myDocumentFonts.everyItem().name;
var myString = "Document Fonts:\r";
for(var myCounter = 0;myCounter<myDocumentFontNames.length; myCounter++){
myString += myDocumentFontNames[myCounter] + "\r";
}
}
myString += "\rApplication Fonts:\r";
for(var myCounter = 0;myCounter<myFontNames.length; myCounter++){
myString += myFontNames[myCounter] + "\r";
}
myStory.contents = myString;
REMARQUE : généralement, le nom des polices se présente sous la forme familyName<tab>fontStyle, où
familyName désigne le nom de la famille de polices, <tab> un caractère de tabulation et fontStyle le
nom du style de la police. Par exemple :
"Adobe Caslon Pro<tab>Semibold Italic"
Application d’une police
Pour appliquer un changement de police local à une plage de texte, utilisez la propriété appliedFont,
comme l’illustre l’extrait de script suivant (dans le script d’apprentissage ApplyFont) :
//Given a font name "myFontName" and a text object "myText"
myText.appliedFont = app.fonts.item(myFontName);
Vous pouvez également appliquer une police en indiquant le nom de la famille de polices et du style de
police, comme l’illustre l’extrait de script suivant :
myText.appliedFont = app.fonts.item("Adobe Caslon Pro");
myText.fontStyle = "Semibold Italic";
Texte et saisie
Mise en forme du texte 48
Modification des propriétés d’un texte
Les objets texte dans InCopy possèdent des dizaines de propriétés correspondant à leurs attributs de
mise en forme. Même un point d’insertion unique est associé à des propriétés qui interviennent sur la
mise en forme du texte, y compris les propriétés du paragraphe contenant le point d’insertion. Le script
d’apprentissage SetTextProperties permet de définir chaque propriété d’un objet texte. Extrait du script :
//Shows how to set all read/write properties of a text object.
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
myStory.contents = "x";
var myTextObject = myStory.characters.item(0);
myTextObject.alignToBaseline = false;
myTextObject.appliedCharacterStyle = myDocument.characterStyles.item("[None]");
myTextObject.appliedFont = app.fonts.item("Minion ProRegular");
myTextObject.appliedLanguage = app.languagesWithVendors.item("English: USA");
myTextObject.appliedNumberingList = myDocument.numberingLists.item("[Default]");
myTextObject.appliedParagraphStyle = myDocument.paragraphStyles.item("[No Paragraph
Style]");
myTextObject.autoLeading = 120;
myTextObject.balanceRaggedLines = BalanceLinesStyle.noBalancing;
myTextObject.baselineShift = 0;
myTextObject.bulletsAlignment = ListAlignment.leftAlign;
myTextObject.bulletsAndNumberingListType = ListType.noList;
myTextObject.bulletsCharacterStyle = myDocument.characterStyles.item("[None]");
myTextObject.bulletsTextAfter = "^t";
myTextObject.capitalization = Capitalization.normal;
myTextObject.composer = "Adobe Paragraph Composer";
myTextObject.desiredGlyphScaling = 100;
myTextObject.desiredLetterSpacing = 0;
myTextObject.desiredWordSpacing = 100;
myTextObject.dropCapCharacters = 0;
myTextObject.dropCapLines = 0;
myTextObject.dropCapStyle = myDocument.characterStyles.item("[None]");
myTextObject.dropcapDetail = 0;
//More text properties in the tutorial script.
Modification de la couleur du texte
Vous pouvez appliquer des couleurs de fond et de contour aux caractères d’un texte, comme l’illustre
l’extrait de script suivant (dans le script d’apprentissage TextColors) :
//Given two colors "myColorA" and "myColorB"...
var myStory = myDocument.stories.item(0);
//Enter text in the text frame.
myStory.contents = "Text\rColor"
var myText = myStory.paragraphs.item(0)
myText.pointSize = 72;
myText.justification = Justification.centerAlign;
//Apply a color to the fill of the text.
myText.fillColor = myColorA;
//Use the itemByRange method to apply the color to the stroke of the text.
myText.strokeColor = myColorB;
var myText = myStory.paragraphs.item(1)
myText.strokeWeight = 3;
Texte et saisie
Mise en forme du texte 49
myText.pointSize = 144;
myText.justification = Justification.centerAlign;
myText.fillColor = myColorB;
myText.strokeColor = myColorA;
myText.strokeWeight = 3;
Création et application des styles
Même si vous pouvez utiliser des scripts pour appliquer une mise en forme locale, comme dans certains
exemples décrits précédemment dans ce chapitre, il est probablement préférable d’utiliser des styles de
caractère et de paragraphe pour mettre en forme le texte. Les styles permettent de créer un lien entre le
texte mis en forme et le style, ce qui facilite la redéfinition du style, la collecte du texte mis en forme avec
un style donné ou la recherche et/ou la modification d’un texte. Les styles de paragraphe et de caractère
sont essentiels à la productivité liée à la mise en forme d’un texte et doivent être un élément central pour
n’importe quel script appliquant une mise en forme au texte.
L’extrait de script suivant montre comment créer et appliquer des styles de paragraphe et de caractère
(pour consulter le script complet, voir CreateStyles) :
//Shows how to create and apply a paragraph style and a character style.
var myParagraphStyle, myCharacterStyle, myColor, myName;
//Create an example document.
var myDocument = app.documents.add();
//Create a color for use by one of the paragraph styles we'll create.
try{
myColor = myDocument.colors.item("Red");
//If the color does not exist, trying to get its name generates an error.
myName = myColor.name;
}
catch (myError){
//The color style did not exist, so create it.
myColor = myDocument.colors.add({name:"Red", model:ColorModel.process,
colorValue:[0, 100, 100, 0]});
}
var myStory = myDocument.stories.item(0);
//Fill the text frame with placeholder text.
myStory.textContainers[0].contents = "Normal text. Text with a character style applied
to it. More normal text.";
//Create a character style named "myCharacterStyle" if
//no style by that name already exists.
try{
myCharacterStyle = myDocument.characterStyles.item("myCharacterStyle");
//If the style does not exist, trying to get its name generates an error.
myName = myCharacterStyle.name;
}
catch (myError){
//The style did not exist, so create it.
myCharacterStyle = myDocument.characterStyles.add({name:"myCharacterStyle"});
}
//At this point, the variable myCharacterStyle contains a reference to a
//character-style object, which you can now use to specify formatting.
myCharacterStyle.fillColor = myColor;
//Create a paragraph style named "myParagraphStyle" if
//no style by that name already exists.
try{
myParagraphStyle = myDocument.paragraphStyles.item("myParagraphStyle");
//If the paragraph style does not exist, trying to get its name generates
//an error.
Texte et saisie
Mise en forme du texte 50
myName = myParagraphStyle.name;
}
catch (myError){
//The paragraph style did not exist, so create it.
myParagraphStyle = myDocument.paragraphStyles.add({name:"myParagraphStyle"});
}
//At this point, the variable myParagraphStyle contains a reference to a
//paragraph-style object, which you can now use to specify formatting.
myStory.texts.item(0).applyParagraphStyle(myParagraphStyle, true);
var myStartCharacter = myStory.characters.item(13);
var myEndCharacter = myStory.characters.item(54);
myStory.texts.itemByRange(myStartCharacter,
myEndCharacter).applyCharacterStyle(myCharacterStyle);
Pourquoi utiliser la méthode applyParagraphStyle au lieu de définir la propriété
appliedParagraphStyle de l’objet texte ? La méthode offre la possibilité de redéfinir la mise en forme
actuelle, tandis que la définition de la propriété sur un style permet de conserver la mise en forme locale.
Pourquoi vérifier l’existence d’un style lorsque vous créez un document ? Il peut s’agir d’un style par défaut
dans l’application. Si tel est le cas, la création d’un style portant le même nom produit une erreur.
Les styles imbriqués appliquent une mise en forme de style de caractère à un paragraphe selon un
modèle. L’extrait de script suivant permet de créer et d’appliquer un style de paragraphe contenant des
styles imbriqués (pour consulter le script complet, voir NestedStyles) :
//At this point, the variable myParagraphStyle contains a reference to a
//paragraph-style object, which you can now use to specify formatting.var myNestedStyle
= myParagraphStyle.nestedStyles.add({appliedCharacterStyle:myCharacterStyle,
delimiter:".", inclusive:true, repetition:1});
var myStartCharacter = myStory.characters.item(0);
var myEndCharacter = myStory.characters.item(-1);
//Use the itemByRange method to apply the paragraph to all text in the
//story. (Note the story object does not have the applyStyle method.)
myStory.texts.itemByRange(myStartCharacter,
myEndCharacter).applyParagraphStyle(myParagraphStyle, true);
Suppression d’un style
Lorsque vous supprimez un style à l’aide de l’interface utilisateur, vous pouvez choisir la manière de mettre
en forme un texte référencé par ce style. Les scripts InCopy fonctionnent de la même manière, comme
l’illustre l’extrait de script suivant (dans le script d’apprentissage RemoveStyle) :
//Remove the paragraph style myParagraphStyleA and replace with myParagraphStyleB.
myParagraphStyleA.remove(myDocument.paragraphStyles.item("myParagraphStyleB"));
Importation de styles de paragraphe et de caractère
Vous pouvez importer des styles de paragraphe et de caractère à partir d’autres documents InCopy.
L’extrait de script suivant montre comment procéder (pour consulter le script complet,
voir ImportTextStyles) :
//Import the styles from the saved document.
//importStyles parameters:
//Format as ImportFormat enumeration. Options for text styles are:
//
ImportFormat.paragraphStylesFormat
//
ImportFormat.characterStylesFormat
//
ImportFormat.textStylesFormat
Texte et saisie
Recherche et modification de texte 51
//From as File
//GlobalStrategy as GlobalClashResolutionStrategy enumeration. Options are:
//
GlobalClashResolutionStrategy.doNotLoadTheStyle
//
GlobalClashResolutionStrategy.loadAllWithOverwrite
//
GlobalClashResolutionStrategy.loadAllWithRename
myDocument.importStyles(ImportFormat.textStylesFormat, File(myFilePath),
GlobalClashResolutionStrategy.loadAllWithOverwrite);
Recherche et modification de texte
La fonction de recherche/modification est l’un des outils InCopy les plus performants pour la manipulation
du texte. Elle est entièrement prise en charge par les scripts qui peuvent y recourir pour exécuter des
opérations qui dépassent le cadre d’utilisation de l’interface utilisateur InCopy. Il existe dans InCopy trois
méthodes de recherche de texte :
X
Vous pouvez rechercher un texte et des attributs de mise en forme et les redéfinir. Ce type d’opération
de recherche et de modification utilise les objets findTextPreferences et changeTextPreferences
pour définir les paramètres des méthodes findText et changeText.
X
Vous pouvez effectuer une recherche à partir d’expressions régulières ou utiliser la commande
« grep ». Ce type d’opération de recherche et de modification utilise les objets findGrepPreferences
et changeGrepPreferences pour définir les paramètres des méthodes findGrep et changeGrep.
X
Vous pouvez rechercher des glyphes spécifiques (et leur mise en forme) et les remplacer par d’autres
glyphes et attributs de mise en forme. Ce type d’opération de recherche et de modification utilise les
objets findGlyphPreferences et changeGlyphPreferences pour définir les paramètres des
méthodes findGlyph et changeGlyph.
Toutes les méthodes de recherche et de modification adoptent un seul paramètre facultatif, reverseOrder,
qui définit l’ordre dans lequel les résultats de la recherche sont renvoyés. Si vous utilisez les résultats d’une
opération de recherche ou de modification pour ajouter du texte à un article ou en retirer, vous pouvez
rencontrer un problème de références de texte incorrectes, comme décrit à la section « Objets texte et
itération » à la page 43. Dans ce cas, vous pouvez soit définir les boucles en mode inverse dans la collection
d’objets texte renvoyés, soit faire en sorte que l’opération de recherche renvoie les résultats dans l’ordre
inverse, puis effectuer normalement une itération dans la collection.
Préférences de recherche/modification
Avant d’effectuer une recherche, il est recommandé d’effacer les préférences de recherche et de
modification, pour s’assurer que les paramètres de recherche précédents n’ont aucun effet sur votre
recherche. Vous devez également définir quelques préférences de recherche et de modification pour
indiquer le texte, la mise en forme, l’expression régulière ou le glyphe à rechercher et/ou modifier. Une
opération de recherche/modification courante comprend les étapes suivantes :
1. Effacer les préférences de recherche/modification. Selon le type d’opération de
recherche/modification, le processus peut prendre l’une des trois formes suivantes :
//find/change text preferences
app.findTextPreferences = NothingEnum.nothing;
app.changeTextPreferences = NothingEnum.nothing;
//find/change grep preferences
app.findGrepPreferences = NothingEnum.nothing;
app.changeGrepPreferences = NothingEnum.nothing;
//find/change glyph preferences
app.findGlyphPreferences = NothingEnum.nothing;
app.changeGlyphPreferences = NothingEnum.nothing;
2. Définir les paramètres de recherche/modification.
Texte et saisie
Recherche et modification de texte 52
3. Exécuter l’opération de recherche/modification.
4. Effacer de nouveau les préférences de recherche/modification.
Recherche de texte
L’extrait de script suivant permet de rechercher une chaîne de caractères spécifiée. Même si l’extrait de
script fait porter la recherche sur le document entier, vous pouvez aussi effectuer une recherche dans les
articles, les blocs de texte, les paragraphes, les colonnes de texte ou tout autre objet texte. La méthode
findText et ses paramètres sont identiques pour tous les objets texte. (Pour consulter le script complet,
voir FindText.)
//Clear the find/change preferences.
app.findTextPreferences = NothingEnum.nothing;
app.changeTextPreferences = NothingEnum.nothing;
//Search the document for the string "Text".
app.findTextPreferences.findWhat = "text";
//Set the find options.
app.findChangeTextOptions.caseSensitive = false;
app.findChangeTextOptions.includeFootnotes = false;
app.findChangeTextOptions.includeHiddenLayers = false;
app.findChangeTextOptions.includeLockedLayersForFind = false;
app.findChangeTextOptions.includeLockedStoriesForFind = false;
app.findChangeTextOptions.includeMasterPages = false;
app.findChangeTextOptions.wholeWord = false;
var myFoundItems = app.documents.item(0).findText();
alert("Found " + myFoundItems.length + " instances of the search string.");
L’extrait de script suivant permet de rechercher une chaîne de caractères spécifiée et de la remplacer par
une chaîne différente (pour consulter le script complet, voir ChangeText) :
//Clear the find/change preferences.
app.findTextPreferences = NothingEnum.nothing;
app.changeTextPreferences = NothingEnum.nothing;
//Set the find options.
app.findChangeTextOptions.caseSensitive = false;
app.findChangeTextOptions.includeFootnotes = false;
app.findChangeTextOptions.includeHiddenLayers = false;
app.findChangeTextOptions.includeLockedLayersForFind = false;
app.findChangeTextOptions.includeLockedStoriesForFind = false;
app.findChangeTextOptions.includeMasterPages = false;
app.findChangeTextOptions.wholeWord = false;
//Search the document for the string "copy" and change it to "text".
app.findTextPreferences.findWhat = "copy";
app.changeTextPreferences.changeTo = "text";
app.documents.item(0).changeText();
//Clear the find/change preferences after the search.
app.findTextPreferences = NothingEnum.nothing;
app.changeTextPreferences = NothingEnum.nothing;
Texte et saisie
Recherche et modification de texte 53
Recherche et remplacement d’une mise en forme
Pour rechercher et remplacer la mise en forme du texte, définissez d’autres propriétés des objets
findTextPreferences et changeTextPreferences, comme l’illustre l’extrait de script suivant (dans le
script d’apprentissage FindChangeFormatting) :
//Clear the find/change preferences.
app.findTextPreferences = NothingEnum.nothing;
app.changeTextPreferences = NothingEnum.nothing;
//Set the find options.
app.findChangeTextOptions.caseSensitive = false;
app.findChangeTextOptions.includeFootnotes = false;
app.findChangeTextOptions.includeHiddenLayers = false;
app.findChangeTextOptions.includeLockedLayersForFind = false;
app.findChangeTextOptions.includeLockedStoriesForFind = false;
app.findChangeTextOptions.includeMasterPages = false;
app.findChangeTextOptions.wholeWord = false;
//Search the document for the 24 point text and change it to 10 point text.
app.findTextPreferences.pointSize = 24;
app.changeTextPreferences.pointSize = 10;
app.documents.item(0).changeText();
//Clear the find/change preferences after the search.
app.findTextPreferences = NothingEnum.nothing;
app.changeTextPreferences = NothingEnum.nothing;
Vous pouvez également rechercher une chaîne de caractères et appliquer une mise en forme, comme
l’illustre l’extrait de script suivant (dans le script d’apprentissage FindChangeStringFormatting) :
//Clear the find/change preferences.
app.findTextPreferences = NothingEnum.nothing;
app.changeTextPreferences = NothingEnum.nothing;
//Set the find options.
app.findChangeTextOptions.caseSensitive = false;
app.findChangeTextOptions.includeFootnotes = false;
app.findChangeTextOptions.includeHiddenLayers = false;
app.findChangeTextOptions.includeLockedLayersForFind = false;
app.findChangeTextOptions.includeLockedStoriesForFind = false;
app.findChangeTextOptions.includeMasterPages = false;
app.findChangeTextOptions.wholeWord = false;
app.findTextPreferences.findWhat = "WIDGET^9^9^9^9";
//The following line will only work if your default font
//has a font style named "Bold" if not, change the text to
//a font style used by your default font.
app.changeTextPreferences.fontStyle = "Bold";
//Search the document. In this example, we'll use the
//InCopy search metacharacter "^9" to find any digit.
var myFoundItems = app.documents.item(0).changeText();
alert("Changed " + myFoundItems.length + " instances of the search string.");
//Clear the find/change preferences after the search.
app.findTextPreferences = NothingEnum.nothing;
app.changeTextPreferences = NothingEnum.nothing;
Texte et saisie
Recherche et modification de texte 54
Utilisation de l’outil Grep
InCopy prend en charge la recherche/modification des expressions régulières à l’aide des
méthodes findGrep et changeGrep. Les opérations de recherche/modification des expressions régulières
permettent également de rechercher du texte dans un format particulier ou de remplacer la mise en forme
du texte par des attributs de mise en forme spécifiés dans les propriétés de l’objet
changeGrepPreferences. L’extrait de script suivant montre comment utiliser ces méthodes et les objets
de préférences associés (pour consulter le script complet, voir FindGrep) :
//Clear the find/change preferences.
app.findGrepPreferences = NothingEnum.nothing;
app.changeGrepPreferences = NothingEnum.nothing;
//Set the find options.
app.findChangeGrepOptions.includeFootnotes = false;
app.findChangeGrepOptions.includeHiddenLayers = false;
app.findChangeGrepOptions.includeLockedLayersForFind = false;
app.findChangeGrepOptions.includeLockedStoriesForFind = false;
app.findChangeGrepOptions.includeMasterPages = false;
//Regular expression for finding an email address.
app.findGrepPreferences.findWhat = "(?i)[A-Z]*?@[A-Z]*?[.]...";
//Apply the change to 24-point text only.
app.findGrepPreferences.pointSize = 24;
app.changeGrepPreferences.underline = true;
app.documents.item(0).changeGrep();
//Clear the find/change preferences after the search.
app.findGrepPreferences = NothingEnum.nothing;
app.changeGrepPreferences = NothingEnum.nothing;
REMARQUE : il manque à l’objet findChangeGrepOptions deux propriétés de l’objet
findChangeTextOptions : wholeWord etcaseSensitive. En fait, vous pouvez définir ces options en
utilisant l’expression régulière elle-même. Utilisez (?i) pour activer le respect de la casse et (?-i) pour le
désactiver. Utilisez \> pour faire coïncider le début d’un mot et \< la fin d’un mot, ou utilisez \b pour faire
coïncider les limites d’un mot.
Une utilisation pratique de l’outil de recherche/modification grep consiste à convertir le balisage d’un
texte (par exemple, certaines formes de balisage du texte brut avec des instructions de mise en forme)
en texte InCopy mis en forme. Les balises de paragraphe PageMaker (à différencier des fichiers de format
texte balisés PageMaker) illustrent un schéma de balisage de texte simplifié. Dans un fichier texte balisé
selon ce schéma, le nom des styles de paragraphe s’affiche en début de paragraphe, comme indiqué dans
ces exemples :
<heading1>This is a heading.
<body_text>This is body text.
Nous pouvons créer un script qui utilise l’outil de recherche grep dans le cadre des opérations de
recherche/modification de texte pour appliquer la mise en forme au texte et supprimer les balises de
marquage, comme l’illustre l’extrait de script suivant (dans le script d’apprentissage ReadPMTags) :
function myReadPMTags(myStory){
var myName, myString, myStyle, myStyleName;
var myDocument = app.documents.item(0);
//Reset the findGrepPreferences to ensure that previous settings
//do not affect the search.
app.findGrepPreferences = NothingEnum.nothing;
app.changeGrepPreferences = NothingEnum.nothing;
//Find the tags (since this is a JavaScript string, backslashes must be escaped).
app.findGrepPreferences.findWhat = "(?i)^<\\s*\\w+\\s*>";
Texte et saisie
Recherche et modification de texte 55
var myFoundItems = myStory.findGrep();
if(myFoundItems.length != 0){
var myFoundTags = new Array;
for(var myCounter = 0; myCounter<myFoundItems.length; myCounter++){
myFoundTags.push(myFoundItems[myCounter].contents);
}
myFoundTags = myRemoveDuplicates(myFoundTags);
//At this point, we have a list of tags to search for.
for(myCounter = 0; myCounter < myFoundTags.length; myCounter++){
myString = myFoundTags[myCounter];
//Find the tag using findWhat.
app.findTextPreferences.findWhat = myString;
//Extract the style name from the tag.
myStyleName = myString.substring(1, myString.length-1);
//Create the style if it does not already exist.
try{
myStyle = myDocument.paragraphStyles.item(myStyleName);
myName = myStyle.name;
}
catch (myError){
myStyle = myDocument.paragraphStyles.add({name:myStyleName});
}
//Apply the style to each instance of the tag.
app.changeTextPreferences.appliedParagraphStyle = myStyle;
myStory.changeText();
//Reset the changeTextPreferences.
app.changeTextPreferences = NothingEnum.nothing;
//Set the changeTo to an empty string.
app.changeTextPreferences.changeTo = "";
//Search to remove the tags.
myStory.changeText();
//Reset the find/change preferences again.
app.changeTextPreferences = NothingEnum.nothing;
}
}
//Reset the findGrepPreferences.
app.findGrepPreferences = NothingEnum.nothing;
}
function myRemoveDuplicates(myArray){
//Semi-clever method of removing duplicate array items; much faster
//than comparing every item to every other item!
var myNewArray = new Array;
myArray = myArray.sort();
myNewArray.push(myArray[0]);
if(myArray.length > 1){
for(var myCounter = 1; myCounter < myArray.length; myCounter ++){
if(myArray[myCounter] != myNewArray[myNewArray.length -1]){
myNewArray.push(myArray[myCounter]);
}
}
}
return myNewArray;
}
Texte et saisie
Tableaux 56
Recherche de glyphes
Vous pouvez rechercher et modifier des caractères individuels dans une police particulière avec les
méthodes findGlyph et changeGlyph, ainsi que les objets findGlyphPreferences et
changeGlyphPreferences associés. L’extrait de script suivant permet de rechercher et remplacer un
glyphe dans un exemple de document (pour consulter le script complet, voir FindChangeGlyphs) :
//Clear glyph search preferences.
app.findGlyphPreferences = NothingEnum.nothing;
app.changeGlyphPreferences = NothingEnum.nothing;
var myDocument = app.documents.item(0);
//You must provide a font that is used in the document for the
//appliedFont property of the findGlyphPreferences object.
app.findGlyphPreferences.appliedFont = app.fonts.item("Minion ProRegular");
//Provide the glyph ID, not the glyph Unicode value.
app.findGlyphPreferences.glyphID = 500;
//The appliedFont of the changeGlyphPreferences object can be
//any font available to the application.
app.changeGlyphPreferences.appliedFont = app.fonts.item("Times New RomanRegular");
app.changeGlyphPreferences.glyphID = 374;
myDocument.changeGlyph();
//Clear glyph search preferences.
app.findGlyphPreferences = NothingEnum.nothing;
app.changeGlyphPreferences = NothingEnum.nothing;
Tableaux
Il est possible de créer des tableaux à partir d’un texte existant à l’aide de la méthode
convertTextToTable ou de créer un tableau vide dans un article à n’importe quel point d’insertion.
L’extrait de script suivant illustre trois méthodes différentes pour créer un tableau (pour consulter le script
complet, voir MakeTable) :
var myStory = myDocument.stories.item(0);
var myStartCharacter = myStory.paragraphs.item(6).characters.item(0);
var myEndCharacter = myStory.paragraphs.item(6).characters.item(-2);
var myText = myStory.texts.itemByRange(myStartCharacter, myEndCharacter);
//The convertToTable method takes three parameters:
//[ColumnSeparator as string]
//[RowSeparator as string]
//[NumberOfColumns as integer] (only used if the ColumnSeparator
//and RowSeparator values are the same)
//In the last paragraph in the story, columns are separated by commas
//and rows are separated by semicolons, so we provide those characters
//to the method as parameters.
var myTable = myText.convertToTable(",",";");
var myStartCharacter = myStory.paragraphs.item(1).characters.item(0);
var myEndCharacter = myStory.paragraphs.item(4).characters.item(-2);
var myText = myStory.texts.itemByRange(myStartCharacter, myEndCharacter);
//In the second through the fifth paragraphs, colums are separated by
//tabs and rows are separated by returns. These are the default delimiter
//parameters, so we don't need to provide them to the method.
var myTable = myText.convertToTable();
//You can also explicitly add a table--you don't have to convert text to a table.
var myTable = myStory.insertionPoints.item(-1).tables.add();
myTable.columnCount = 3;
myTable.bodyRowCount = 3;
Texte et saisie
Tableaux 57
L’extrait de script suivant permet de fusionner les cellules d’un tableau (pour consulter le script complet,
voir MergeTableCells) :
var myDocument = app.documents.add();
var myStory = myDocument.stories.item(0);
var myString = "Table\r";
myStory.contents = myString;
var myTable = myStory.insertionPoints.item(-1).tables.add();
myTable.columnCount = 4;
myTable.bodyRowCount = 4;
//Merge all cells in the first column.
myTable.cells.item(0).merge(myTable.columns.item(0).cells.item(-1));
//Convert column 2 into 2 cells (rather than 4).
myTable.columns.item(1).cells.item(-1).merge(myTable.columns.item(1).cells.item(-2));
myTable.columns.item(1).cells.item(0).merge(myTable.columns.item(1).cells.item(1));
//Merge the last two cells in row 1.
myTable.rows.item(0).cells.item(-2).merge(myTable.rows.item(0).cells.item(-1));
//Merge the last two cells in row 3.
myTable.rows.item(2).cells.item(-2).merge(myTable.rows.item(2).cells.item(-1));
L’extrait de script suivant permet de scinder les cellules d’un tableau (pour consulter le script complet,
voir SplitTableCells) :
myTable.cells.item(0).split(HorizontalOrVertical.horizontal);
myTable.columns.item(0).split(HorizontalOrVertical.vertical);
myTable.cells.item(0).split(HorizontalOrVertical.vertical);
myTable.rows.item(-1).split(HorizontalOrVertical.horizontal);
myTable.cells.item(-1).split(HorizontalOrVertical.vertical);
for(myRowCounter = 0; myRowCounter < myTable.rows.length; myRowCounter ++){
myRow = myTable.rows.item(myRowCounter);
for(myCellCounter = 0; myCellCounter < myRow.cells.length; myCellCounter ++){
myString = "Row: " + myRowCounter + " Cell: " + myCellCounter;
myRow.cells.item(myCellCounter).contents = myString;
}
}
L’extrait de script suivant permet de créer des lignes d’en-tête et de notes de bas de page dans un tableau
(pour consulter le script complet, voir HeaderAndFooterRows) :
var myTable = app.documents.item(0).stories.item(0).tables.item(0);
//Convert the first row to a header row.
myTable.rows.item(0).rowType = RowTypes.headerRow;
//Convert the last row to a footer row.
myTable.rows.item(-1).rowType = RowTypes.footerRow;
L’extrait de script suivant permet d’appliquer des attributs de mise en forme à un tableau (pour consulter
le script complet, voir TableFormatting) :
var myTable = myDocument.stories.item(0).tables.item(0);
//Convert the first row to a header row.
myTable.rows.item(0).rowType = RowTypes.headerRow;
//Use a reference to a swatch, rather than to a color.
myTable.rows.item(0).fillColor = myDocument.swatches.item("DGC1_446b");
myTable.rows.item(0).fillTint = 40;
myTable.rows.item(1).fillColor = myDocument.swatches.item("DGC1_446a");
myTable.rows.item(1).fillTint = 40;
myTable.rows.item(2).fillColor = myDocument.swatches.item("DGC1_446a");
myTable.rows.item(2).fillTint = 20;
myTable.rows.item(3).fillColor = myDocument.swatches.item("DGC1_446a");
myTable.rows.item(3).fillTint = 40;
Texte et saisie
Tableaux 58
//Use everyItem to set the formatting of multiple cells at once.
myTable.cells.everyItem().topEdgeStrokeColor = myDocument.swatches.item("DGC1_446b");
myTable.cells.everyItem().topEdgeStrokeWeight = 1;
myTable.cells.everyItem().bottomEdgeStrokeColor =
myDocument.swatches.item("DGC1_446b");
myTable.cells.everyItem().bottomEdgeStrokeWeight = 1;
//When you set a cell stroke to a swatch, make certain you also set the
//stroke weight.
myTable.cells.everyItem().leftEdgeStrokeColor = myDocument.swatches.item("None");
myTable.cells.everyItem().leftEdgeStrokeWeight = 0;
myTable.cells.everyItem().rightEdgeStrokeColor = myDocument.swatches.item("None");
myTable.cells.everyItem().rightEdgeStrokeWeight = 0;
L’extrait de script suivant permet d’ajouter une mise en forme de ligne en alternance à un tableau (pour
consulter le script complet, voir AlternatingRows) :
//Given a table "myTable" containing at least four rows and a document
//"myDocument" containing the colors "DGC1_446a" and "DGC1_446b"...
//Convert the first row to a header row.
myTable.rows.item(0).rowType = RowTypes.headerRow;
//Applly alternating fills to the table.
myTable.alternatingFills = AlternatingFillsTypes.alternatingRows;
myTable.startRowFillColor = myDocument.swatches.item("DGC1_446a");
myTable.startRowFillTint = 60;
myTable.endRowFillColor = myDocument.swatches.item("DGC1_446b");
myTable.endRowFillTint = 50;
L’extrait de script suivant montre comment traiter la sélection lorsque du texte ou des cellules de tableau
sont sélectionnés. Dans cet exemple, le script affiche une alerte pour chaque condition de sélection, mais
un véritable script de production pourrait manipuler les éléments sélectionnés. (Pour consulter le script
complet, voir TableSelection.)
if(app.documents.length != 0){
if(app.selection.length != 0){
switch(app.selection[0].constructor.name){
//When a row, a column, or a range of cells is selected,
//the type returned is "Cell"
case "Cell":
alert("A cell is selected.");
break;
case "Table":
alert("A table is selected.");
break;
case "InsertionPoint":
case "Character":
case "Word":
case "TextStyleRange":
case "Line":
case "Paragraph":
case "TextColumn":
case "Text":
if(app.selection[0].parent.constructor.name == "Cell"){
alert("The selection is inside a table cell.");
}
else{
alert("The selection is not inside a table.");
}
break;
default:
Texte et saisie
Correction automatique 59
alert("The selection is not inside a table.");
break;
}
}
}
Correction automatique
La fonction de correction automatique permet de corriger le texte pendant la saisie. Le script suivant
illustre son mode d’utilisation (pour consulter le script complet, voir Autocorrect) :
//The autocorrect preferences object turns the
//autocorrect feature on or off.
app.autoCorrectPreferences.autoCorrect = true;
app.autoCorrectPreferences.autoCorrectCapitalizationErrors = true;
//Add a word pair to the autocorrect list. Each AutoCorrectTable is linked
//to a specific language.
var myAutoCorrectTable = app.autoCorrectTables.item("English: USA");
//To safely add a word pair to the auto correct table, get the current
//word pair list, then add the new word pair to that array, and then
//set the autocorrect word pair list to the array.
var myWordPairList = myAutoCorrectTable.autoCorrectWordPairList;
//Add a new word pair to the array.
myWordPairList.push(["paragraph", "paragraph"]);
//Update the word pair list.
myAutoCorrectTable.autoCorrectWordPairList = myWordPairList;
//To clear all autocorrect word pairs in the current dictionary:
//myAutoCorrectTable.autoCorrectWordPairList = [[]];
Notes de bas de page
L’extrait de script suivant permet d’ajouter des notes de bas de page à un article (pour consulter le script
complet, voir Footnotes) :
var myWord, myFootnote;
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Add four footnotes at random locations in the story.
for(myCounter = 0; myCounter < 4; myCounter ++){
myWord = myStory.words.item(myGetRandom(0, myStory.words.length));
var myFootnote = myWord.insertionPoints.item(-1).footnotes.add();
//Note: when you create a footnote, it contains text--the footnote
//marker and the separator text (if any). If you try to set the text of
//the footnote by setting the footnote contents, you will delete the
//marker. Instead, append the footnote text, as shown below.
myFootnote.insertionPoints.item(-1).contents = "This is a footnote.";
//This function gets a random number in the range myStart to myEnd.
function myGetRandom(myStart, myEnd){
var myRange = myEnd - myStart;
return myStart + Math.floor(Math.random()*myRange);
}
5
Interfaces utilisateur
Statut de mise à jour du chapitre
CS6
Inchangé
Avec JavaScript, vous pouvez créer des boîtes de dialogue pour les questions de type oui/non et la saisie
de texte, mais vous aurez parfois besoin de créer des boîtes de dialogue plus complexes pour vos scripts.
Avec les scripts InCopy, vous pouvez ajouter des boîtes de dialogue et les compléter avec des éléments
d’interface utilisateur courants, comme des listes déroulantes, des champs d’entrée de texte et des champs
numériques. Pour que votre script puisse collecter les informations entrées par vos soins ou par tout autre
utilisateur et les traiter, utilisez l’objet dialog.
Ce chapitre décrit l’utilisation des scripts de boîte de dialogue InCopy. Les exemples de scripts de ce
chapitre sont présentés par ordre de complexité, en commençant par des scripts très simples et en
progressant vers des opérations plus complexes.
REMARQUE : les scripts InCopy créés dans JavaScript peuvent également inclure des interfaces utilisateur
créées à l’aide du composant Adobe ScriptUI. Ce chapitre contient certains didacticiels de script ScriptUI ;
pour plus de détails, voir le Guide des outils JavaScript Adobe Creative Suite® 3.
Vous devez avoir préalablement lu le Chapitre 2, « Prise en main » et savoir créer, installer et exécuter un script.
Présentation des boîtes de dialogue
Une boîte de dialogue InCopy est un objet de script InCopy comme un autre. La boîte de dialogue peut
contenir plusieurs types d’éléments (appelés collectivement « objets d’interface » (ou widgets), comme
illustré ci-dessous.
60
Interfaces utilisateur
Votre première boîte de dialogue InCopy
61
Les éléments de la figure sont définis dans le tableau suivant :
Elément de boîte de dialogue
Nom InCopy
Text-edit fields
Text editbox control
Numeric-entry fields
Real editbox, integer editbox, measurement
editbox, percent editbox, angle editbox
Pop-up menus
Drop-down control
Control that combines a text-edit field with a
pop-up menu
Combo-box control
Check box
Check-box control
Radio buttons
Radio-button control
L’objet dialog ne contient pas directement de commandes ; c’est le but de l’objet dialogColumn. L’objet
dialogColumns permet de contrôler la position des commandes dans une boîte de dialogue. Dans un
objet dialogColumns, il est possible de diviser une colonne de boîte de dialogue en plusieurs autres
objets dialogColumns ou borderPanels (qui peuvent eux-mêmes être divisés en d’autres objets
dialogColumns et borderPanels).
Comme tout autre objet de script InCopy, les différentes parties d’une boîte de dialogue possèdent leurs
propres propriétés. Par exemple, une commande checkboxControl possède une propriété pour son texte
(staticLabel) et une autre propriété pour son état (checkedState). La commande dropdown possède
une propriété (stringList) qui permet de paramétrer la liste d’options figurant dans son menu.
Pour utiliser une boîte de dialogue dans un script, vous devez créer l’objet dialog, le remplir de
commandes, afficher la boîte de dialogue et rassembler les valeurs de ses commandes afin de les rendre
disponibles pour le script. Les boîtes de dialogue restent dans la mémoire InCopy jusqu’à leur destruction.
De cette façon, vous pouvez conserver une boîte de dialogue en mémoire et faire en sorte que les
données stockées dans ses propriétés soient utilisées par plusieurs scripts. Notez que ces boîtes de
dialogue occupent de l’espace mémoire et doivent être supprimées lorsqu’elles sont inutilisées. En règle
générale, il est préférable de détruire l’objet boîte de dialogue avant la fin de l’exécution du script.
Votre première boîte de dialogue InCopy
Le processus de création d’une boîte de dialogue InCopy est très simple : vous ajoutez une boîte de
dialogue, une colonne à la boîte de dialogue et des commandes à la colonne de la boîte de dialogue.
Le script ci-après illustre ce processus (pour consulter le script complet, voir SimpleDialog).
var myDialog = app.dialogs.add({name:"Simple Dialog"});
//Add a dialog column.
with(myDialog.dialogColumns.add()){
staticTexts.add({staticLabel:"This is a very simple dialog box."});
}
//Show the dialog box.
var myResult = myDialog.show();
//Display a message.
if(myResult == true){
alert("You clicked the OK button.");
}
Interfaces utilisateur
Ajout d’une interface utilisateur à « Hello World »
62
else{
alert("You clicked the Cancel button.");
}
//Remove the dialog box from memory.
myDialog.destroy();
Ajout d’une interface utilisateur à « Hello World »
Dans cet exemple, nous ajoutons une interface utilisateur simple au script d’apprentissage « Hello World »
présenté au Chapitre 2, « Prise en main ». Les options de la boîte de dialogue vous permettent d’indiquer
l’échantillon de texte et de modifier le corps de la police du texte. Pour consulter le script complet,
voir HelloWorldUI.
var myDialog = app.dialogs.add({name:"Simple User Interface Example
Script",canCancel:true});
with(myDialog){
//Add a dialog column.
with(dialogColumns.add()){
//Create a text edit field.
var myTextEditField = textEditboxes.add({editContents:"Hello World!",
minWidth:180});
//Create a number (real) entry field.
var myPointSizeField = realEditboxes.add({editValue:72});
}
}
//Display the dialog box.
var myResult = myDialog.show();
if(myResult == true){
//Get the values from the dialog box controls.
var myString = myTextEditField.editContents;
var myPointSize = myPointSizeField.editValue;
//Remove the dialog box from memory.
myDialog.destroy();
//Create a new document.
var myDocument = app.documents.add()
with(myDocument){
var myStory = myDocument.stories.item(0);
//Enter the text from the dialog box.
myStory.contents=myString;
//Set the size of the text to the size you entered in the dialog box.
myStory.texts.item(0).pointSize = myPointSize;
}
}
else{
//User clicked Cancel, so remove the dialog box from memory.
myDialog.destroy();
}
Interfaces utilisateur
Création d’une interface utilisateur plus complexe
63
Création d’une interface utilisateur plus complexe
Dans l’exemple suivant, nous allons ajouter des commandes supplémentaires et de différents types à notre
boîte de dialogue. L’exemple permet de créer une boîte de dialogue ressemblant à l’illustration ci-dessous.
Pour consulter le script complet, voir ComplexUI.
var myDialog = app.dialogs.add({name:"ComplexUI", canCancel:true});
with(myDialog){
var mySwatchNames = app.swatches.everyItem().name;
//Add a dialog column.
with(dialogColumns.add()){
//Create a border panel.
with(borderPanels.add()){
with(dialogColumns.add()){
with(dialogRows.add()){
//The following line shows how to set a property
//as you create an object.
staticTexts.add({staticLabel:"Message:"});
//The following line shows how to set multiple
//properties as you create an object.
var myTextEditField = textEditboxes.add(
{editContents:"Hello World!", minWidth:180});
}
}
}
//Create another border panel.
with(borderPanels.add()){
with(dialogColumns.add()){
with(dialogRows.add()){
staticTexts.add({staticLabel:"Point Size:"});
//Create a number entry field. Note that this field uses
//editValue rather than editText (as a textEditBox would).
var myPointSizeField = measurementEditboxes.add({editValue:72,
editUnits:MeasurementUnits.points});
}
}
}
//Create another border panel.
with(borderPanels.add()){
with(dialogColumns.add()){
with(dialogRows.add()){
staticTexts.add({staticLabel:"Paragraph Alignment:"});
var myRadioButtonGroup = radiobuttonGroups.add();
with(myRadioButtonGroup){
radiobuttonControls.add({staticLabel:"Left",
checkedState:true});
Interfaces utilisateur
Création d’une interface utilisateur plus complexe
radiobuttonControls.add({staticLabel:"Center"});
radiobuttonControls.add({staticLabel:"Right"});
}
}
}
}
//Create another border panel.
with(borderPanels.add()){
with(dialogColumns.add()){
with(dialogRows.add()){
staticTexts.add({staticLabel:"Text Color:"});
}
var mySwatchDropdown = dropdowns.add({stringList:mySwatchNames,
selectedIndex:4});
}
}
}
}
//Display the dialog box.
if(myDialog.show() == true){
var myParagraphAlignment, myString, myPointSize, myVerticalJustification;
//If the user didn't click the Cancel button,
//then get the values back from the dialog box.
//Get the example text from the text edit field.
var myString = myTextEditField.editContents
//Get the point size from the point size field.
var myPointSize = myPointSizeField.editValue;
//Get the paragraph alignment setting from the radiobutton group.
if(myRadioButtonGroup.selectedButton == 0){
myParagraphAlignment = Justification.leftAlign;
}
else if(myRadioButtonGroup.selectedButton == 1){
myParagraphAlignment = Justification.centerAlign;
}
else{
myParagraphAlignment = Justification.rightAlign;
}
var mySwatchName = mySwatchNames[mySwatchDropdown.selectedIndex];
//Remove the dialog box from memory.
myDialog.destroy();
//Now create the document and apply the properties to the text.
var myDocument = app.documents.add();
with(myDocument.stories.item(0)){
//Set the contents of the story to the string you entered
//in the dialog box.
contents = myString;
//Set the alignment of the paragraph.
texts.item(0).justification = myParagraphAlignment;
//Set the point size of the text.
texts.item(0).pointSize = myPointSize;
//Set the fill color of the text.
texts.item(0).fillColor = myDocument.swatches.item(mySwatchName);
}
}
else{
myDialog.destroy()
}
64
Interfaces utilisateur
Utilisation de ScriptUI
65
Utilisation de ScriptUI
Avec JavaScript, vous pouvez créer et définir des éléments d’interface utilisateur à l’aide du composant de
script Adobe appelé ScriptUI. ScriptUI permet aux créateurs de scripts de créer des panneaux flottants, des
barres de progression et des boîtes de dialogue interactives dont la complexité est bien supérieure à
l’objet dialog intégré d’InCopy.
Cela ne signifie pas, cependant, que les éléments d’interface utilisateur créés à l’aide de ScriptUI ne sont
pas accessibles aux utilisateurs . Les scripts InCopy peuvent exécuter des scripts rédigés dans d’autres
langages de script à l’aide de la méthode .
Création d’une barre de progression avec ScriptUI
L’exemple de script ci-après illustre la création d’une barre de progression à l’aide de JavaScript et ScriptUI,
puis l’utilisation de cette barre de progression à partir d’un script (pour consulter le script complet,
voir ProgressBar).
#targetengine "session"
var myProgressPanel;
var myMaximumValue = 300;
var myProgressBarWidth = 300;
var myIncrement = myMaximumValue/myProgressBarWidth;
myCreateProgressPanel(myMaximumValue, myProgressBarWidth);
function myCreateProgressPanel(myMaximumValue, myProgressBarWidth){
myProgressPanel = new Window('window', 'Progress');
with(myProgressPanel){
myProgressPanel.myProgressBar = add('progressbar', [12, 12, myProgressBarWidth,
24], 0, myMaximumValue);
}
}
L’extrait de script ci-après permet d’appeler la barre de progression créée dans le script ci-dessus à l’aide
d’un script JavaScript distinct (pour consulter le script complet, voir CallProgressBar).
#targetengine "session"
myCreateProgressPanel(20, 400);
myProgressPanel.show();
var myStory = app.documents.item(0).stories.item(0);
for(var myCounter = 0; myCounter < 20; myCounter ++){
//Scale the value change to the maximum value of the progress bar.
myProgressPanel.myProgressBar.value = myCounter/myIncrement;
var myInsertionPoint = myStory.insertionPoints.item(-1);
myInsertionPoint.contents = "This is a paragraph\r.";
}
myProgressPanel.myProgressBar.value = 0;
myProgressPanel.hide();
Interfaces utilisateur
Utilisation de ScriptUI
66
Création d’un panneau avec barre de boutons au moyen de ScriptUI
Si vous voulez exécuter vos scripts en cliquant sur les boutons d’un panneau flottant, vous pouvez en créer
un avec JavaScript et ScriptUI. Peu importe le langage de script utilisé.
Le script d’apprentissage suivant permet de créer un panneau flottant simple. Le panneau peut contenir
une série de boutons, chaque bouton étant associé à un script stocké sur disque. Cliquez sur le bouton,
et le panneau exécute le script (le script, à son tour, peut afficher des boîtes de dialogue ou d’autres
éléments d’interface utilisateur). Le bouton, dans le panneau, peut contenir du texte ou des graphiques.
(Pour consulter le script complet, voir ButtonBar.)
Le script d’apprentissage lit un fichier XML sous la forme suivante :
<buttons>
<button>
<buttonType></buttonType>
<buttonName></buttonName>
<buttonFileName></buttonFileName>
<buttonIconFile></buttonIconFile>
</button>
...
</buttons>
Par exemple :
<buttons>
<button>
<buttonType>text</buttonType>
<buttonName>FindChangeByList</buttonName>
<buttonFileName>/c/buttons/FindChangeByList.jsx</buttonFileName>
<buttonIconFile></buttonIconFile>
</button>
<button>
<buttonType>text</buttonType>
<buttonName>SortParagraphs</buttonName>
<buttonFileName>/c/buttons/SortParagraphs.jsx</buttonFileName>
<buttonIconFile></buttonIconFile>
</button>
</buttons>
Les fonctions suivantes permettent de lire le fichier XML et de configurer la barre de boutons :
#targetengine "session"
var myButtonBar;
main();
function main(){
myButtonBar = myCreateButtonBar();
myButtonBar.show();
}
function myCreateButtonBar(){
var myButtonName, myButtonFileName, myButtonType, myButtonIconFile, myButton;
var myButtons = myReadXMLPreferences();
if(myButtons != ""){
myButtonBar = new Window('window', 'Script Buttons', undefined,
{maximizeButton:false, minimizeButton:false});
with(myButtonBar){
spacing = 0;
margins = [0,0,0,0];
with(add('group')){
spacing = 2;
Interfaces utilisateur
Utilisation de ScriptUI
orientation = 'row';
for(var myCounter = 0; myCounter < myButtons.length(); myCounter++){
myButtonName = myButtons[myCounter].xpath("buttonName");
myButtonType = myButtons[myCounter].xpath("buttonType");
myButtonFileName = myButtons[myCounter].xpath("buttonFileName");
myButtonIconFile = myButtons[myCounter].xpath("buttonIconFile");
if(myButtonType == "text"){
myButton = add('button', undefined, myButtonName);
}
else{
myButton = add('iconbutton', undefined,
File(myButtonIconFile));
}
myButton.scriptFile = myButtonFileName;
myButton.onClick = function(){
myButtonFile = File(this.scriptFile)
app.doScript(myButtonFile);
}
}
}
}
}
return myButtonBar;
}
function myReadXMLPreferences(){
myXMLFile = File.openDialog("Choose the file containing your
button bar defaults");
var myResult = myXMLFile.open("r", undefined, undefined);
var myButtons = "";
if(myResult == true){
var myXMLDefaults = myXMLFile.read();
myXMLFile.close();
var myXMLDefaults = new XML(myXMLDefaults);
var myButtons = myXMLDefaults.xpath("/buttons/button");
}
return myButtons;
}
67
6
Menus
Statut de mise à jour du chapitre
CS6
Inchangé
Les scripts InCopy permettent d’ajouter des éléments de menu, d’en supprimer, d’exécuter des
commandes de menu et d’associer des scripts à des éléments de menu.
Ce chapitre décrit l’utilisation des scripts de menus InCopy. Les exemples de scripts de ce chapitre sont
présentés par ordre de complexité, en commençant par des scripts très simples et en progressant vers des
opérations plus complexes.
Vous devez avoir lu le Chapitre 2, « Prise en main » et savoir créer, installer et exécuter un script.
Présentation du modèle de menu
Le modèle de scripts de menus InCopy comprend une série d’objets qui correspondent aux menus affichés
dans l’interface utilisateur de l’application, notamment les menus associés aux panneaux, ainsi que ceux
affichés dans la barre de menus principale. Un objet menu contient les objets suivants :
X
menuItems : options de menu figurant dans un menu. Cela n’inclut pas les sous-menus.
X
menuSeparators : lignes utilisées pour séparer les options de menu dans un menu.
X
submenus : options de menu qui contiennent d’autres menus.
X
menuElements : tous les objets menuItems, menuSeparators et submenus figurant dans un menu.
X
eventListeners : répondent aux actions d’un utilisateur (ou script) associées à un menu.
X
events : objets events déclenchés par un menu.
Chaque objet menuItem est connecté à un objet menuAction par l’intermédiaire de la propriété
associatedMenuAction. Les propriétés de l’objet menuAction définissent l’action exécutée lorsque
l’élément de menu est sélectionné. En plus des objets menuActions définis par l’interface utilisateur, les
créateurs de scripts InCopy peuvent créer leurs propres objets scriptMenuActions, qui associent un
script à une sélection de menu.
Un objet menuAction ou scriptMenuAction peut être associé à un ou plusieurs objets menuItems, ou
à aucun.
68
Menus
Présentation du modèle de menu
Le diagramme suivant illustre les relations entre les différents objets de menu :
application
menuActions
menuAction
area
checked
enabled
eventListeners
eventListener
id
eventListener
...
index
label
name
events
event
parent
event
...
title
scriptMenuActions
scriptMenuAction
same as menuAction
Pour créer une liste (sous la forme d’un fichier texte) de toutes les actions de menu visibles, exécutez
l’extrait de script suivant (dans le script d’apprentissage GetMenuActions) :
var myMenuActionNames = app.menuActions.everyItem().name;
//Open a new text file.
var myTextFile = File.saveDialog("Save Menu Action Names As", undefined);
//If the user clicked the Cancel button, the result is null.
if(myTextFile != null){
//Open the file with write access.
myTextFile.open("w");
for(var myCounter = 0; myCounter < myMenuActionNames.length; myCounter++){
myTextFile.writeln(myMenuActionNames[myCounter]);
}
myTextFile.close();
}
69
Menus
Présentation du modèle de menu
70
Pour créer une liste (sous la forme d’un fichier texte) de tous les menus disponibles, exécutez l’extrait de
script suivant (pour consulter la liste complète des scripts, voir le script d’apprentissage GetMenuNames).
Notez que ces scripts peuvent être très lents, car il existe un grand nombre de noms de menu dans InCopy.
var myMenu;
//Open a new text file.
var myTextFile = File.saveDialog("Save Menu Action Names As", undefined);
//If the user clicked the Cancel button, the result is null.
if(myTextFile != null){
//Open the file with write access.
myTextFile.open("w");
for(var myMenuCounter = 0;myMenuCounter< app.menus.length; myMenuCounter++){
myMenu = app.menus.item(myMenuCounter);
myTextFile.writeln(myMenu.name);
myProcessMenu(myMenu, myTextFile);
}
myTextFile.close();
alert("done!");
}
function myProcessMenu(myMenu, myTextFile){
var myMenuElement;
var myIndent = myGetIndent(myMenu);
for(var myCounter = 0; myCounter < myMenu.menuElements.length; myCounter++){
myMenuElement = myMenu.menuElements.item(myCounter);
if(myMenuElement.getElements()[0].constructor.name != "MenuSeparator"){
myTextFile.writeln(myIndent + myMenuElement.name);
if(myMenuElement.getElements()[0].constructor.name == "Submenu"){
if(myMenuElement.menuElements.length > 0){
myProcessMenu(myMenuElement, myTextFile);
}
}
}
}
}
function myGetIndent(myObject){
var myString = "\t";
var myDone = false;
do{
if((myObject.parent.constructor.name == "Menu")||
(myObject.parent.constructor.name == "Application")){
myDone = true;
}
else{
myString = myString + "\t";
myObject = myObject.parent;
}
}while(myDone == false)
return myString;
}
Menus
Exécution d’une action de menu à partir d’un script
71
Localisation et noms de menu
Avec les scripts InCopy, les objets menuItems, menus, menuActions et submenus sont désignés par un
nom. Par conséquent, les scripts doivent s’appuyer sur une méthode de recherche d’objets qui soit
indépendante de la langue installée de l’application. Pour cela, vous pouvez utiliser une base de données
interne de chaînes qui font référence à un élément spécifique, indépendamment de la langue. Par
exemple, pour obtenir le nom (indépendamment de la langue) d’une action de menu, vous pouvez utiliser
l’extrait de script suivant (pour consulter le script complet, voir GetKeyStrings) :
var myString = "";
var myMenuAction = app.menuActions.item("$ID/Convert to Note");
var myKeyStrings = app.findKeyStrings(myMenuAction.name);
if(myKeyStrings.constructor.name == "Array"){
for(var myCounter = 0; myCounter < myKeyStrings.length; myCounter ++){
myString += myKeyStrings[myCounter] + "\r";
}
}
else{
myString = myKeyStrings;
}
alert(myString);
REMARQUE : il est préférable d’obtenir le nom indépendant de la langue d’un objet menuAction plutôt
que celui d’un objet menu, menuItem ou submenu, parce que le titre d’un objet menuAction sera
vraisemblablement une chaîne unique. La plupart des autres objets de menu renvoient plusieurs chaînes
si vous utilisez la méthode getKeyStrings.
Une fois que vous disposez de la chaîne indépendante de la langue à utiliser, vous pouvez l’inclure dans
vos scripts. Les scripts qui utilisent ces chaînes fonctionneront correctement dans les langues différentes
de celle de votre version InCopy.
Pour traduire une chaîne indépendante de la langue dans la langue actuelle, utilisez l’extrait de script
suivant (dans le script d’apprentissage TranslateKeyString) :
var myString = app.translateKeyString("$ID/Convert to Note");
alert(myString);
Exécution d’une action de menu à partir d’un script
Les objets menuActions intégrés d’InCopy peuvent être exécutés à partir d’un script. L’objet menuAction ne
doit pas être nécessairement associé à un objet menuItem ; cependant, l’exécution d’un objet menuItem à
partir d’un script est en tout point identique à la sélection d’une option de menu dans l’interface utilisateur. Si
la sélection de l’option de menu affiche une boîte de dialogue, l’exécution de l’objet menuAction
correspondant à partir d’un script affiche également une boîte de dialogue.
Le script suivant illustre le mode d’exécution d’un objet menuAction à partir d’un script (pour consulter le
script complet, voir InvokeMenuAction) :
//Get a reference to a menu action.
var myMenuAction = app.menuActions.item("$ID/Convert to Note");
//Run the menu action. This example action will fail if you do not
//have text selected.
myMenuAction.invoke();
Menus
Ajout de menus et d’éléments de menu 72
REMARQUE : en règle générale, évitez d’essayer d’automatiser les processus InCopy en codant les actions de
menu et les sélections de l’interface utilisateur ; le modèle d’objet de script InCopy est un outil de travail
bien plus performant. Les actions de menu dépendent d’un certain nombre de conditions d’interface
utilisateur, comme la sélection et l’état de la fenêtre. Les scripts utilisant le modèle d’objet sollicitent
directement les objets d’un document InCopy, ce qui signifie qu’ils ne dépendent pas de l’interface
utilisateur ; leur rapidité et leur cohérence en sont ainsi améliorées.
Ajout de menus et d’éléments de menu
Les scripts peuvent également créer des menus et des éléments de menu ou en supprimer, comme dans
l’interface utilisateur InCopy. L’exemple de script suivant illustre la duplication du contenu d’un sous-menu
dans un nouveau menu, à un autre emplacement de menu (pour consulter le script complet,
voir CustomizeMenu) :
var myMainMenu = app.menus.item("Main");
var myTypeMenu = myMainMenu.menuElements.item("Type");
var myFontMenu = myTypeMenu.menuElements.item("Font");
var myKozukaMenu = myFontMenu.submenus.item("Kozuka Mincho Pro ");
var mySpecialFontMenu = myMainMenu.submenus.add("Kozuka Mincho Pro");
for(myCounter = 0;myCounter < myKozukaMenu.menuItems.length; myCounter++){
var myAssociatedMenuAction =
myKozukaMenu.menuItems.item(myCounter).associatedMenuAction;
mySpecialFontMenu.menuItems.add(myAssociatedMenuAction);
}
Pour supprimer le menu personnalisé ajouté par le script ci-dessus, exécutez le script
RemoveSpecialFontMenu.
var myMainMenu = app.menus.item("Main");
var mySpecialFontMenu = myMainMenu.submenus.item("Kozuka Mincho Pro");
mySpecialFontMenu.remove();
Menus et événements
Les menus et les sous-menus génèrent des événements lorsqu’ils sont sélectionnés dans l’interface
utilisateur, et les objets menuActions et scriptMenuActions génèrent des événements lorsqu’ils sont
utilisés. Les scripts peuvent installer des objets eventListeners pour répondre à ces événements. Le
tableau suivant illustre les événements des différents composants de scripts de menu :
Objet
Evénement
Description
menu
beforeDisplay
Exécute le script associé avant l’affichage du contenu du menu.
menuAction
afterInvoke
Exécute le script associé lorsque l’objet menuItem associé est
sélectionné, mais à la suite de l’événement onInvoke.
beforeInvoke
Exécute le script associé lorsque l’objet menuItem associé est
sélectionné, mais avant l’événement onInvoke.
Menus
Utilisation des objets d’action de menu de script
Objet
Evénement
Description
scriptMenuAction
afterInvoke
Exécute le script associé lorsque l’objet menuItem associé est
sélectionné, mais à la suite de l’événement onInvoke.
beforeInvoke
Exécute le script associé lorsque l’objet menuItem associé est
sélectionné, mais avant l’événement onInvoke.
beforeDisplay
Exécute le script associé avant une demande interne de l’état
activé/coché de l’objet
scriptMenuActionscriptMenuAction.
onInvoke
Exécute le script associé lorsque l’objet scriptMenuAction
est appelé.
beforeDisplay
Exécute le script associé avant l’affichage du contenu de
l’objet submenu.
submenu
73
Pour plus de détails sur les objets events et eventListeners, voir le Chapitre 7, « Evénements ».
Pour modifier les éléments affichés dans un menu, ajoutez un objet eventListener pour l’événement
event beforeDisplay. Lorsque le menu est sélectionné, l’objet eventListener peut alors exécuter un
script qui active ou désactive les éléments de menu, modifie le nom de l’élément de menu ou exécute
d’autres tâches associées au menu. Cette opération est utilisée en interne pour modifier la liste des menus
pour les polices disponibles, les documents récents ou les fenêtres ouvertes.
Utilisation des objets d’action de menu de script
Vous pouvez utiliser un objet scriptMenuAction pour créer un objet menuAction dont le comportement
est implémenté par l’intermédiaire du script prévu pour être exécuté lorsque l’événement event onInvoke
est déclenché.
Le script suivant illustre la création d’un objet scriptMenuAction et son association à un élément de
menu (pour consulter le script complet, voir MakeScriptMenuAction). Ce script affiche simplement une
alerte lorsque l’élément de menu est sélectionné.
var mySampleScriptAction = app.scriptMenuActions.add("Display Message");
var myEventListener = mySampleScriptAction.eventListeners.add("onInvoke",
function(){alert("This menu item was added by a script.");});
//If the submenu "Script Menu Action" does not already exist, create it.
try{
var mySampleScriptMenu = app.menus.item("$ID/Main").submenus.item(
"Script Menu Action");
mySampleScriptMenu.title;
}
catch (myError){
var mySampleScriptMenu = app.menus.item("$ID/Main").submenus.add
("Script Menu Action");
}
var mySampleScriptMenuItem = mySampleScriptMenu.menuItems.add(mySampleScriptAction);
Menus
Utilisation des objets d’action de menu de script
74
Pour supprimer les objets menu, submenu, menuItem et scriptMenuAction créés par le script ci-dessus,
exécutez l’extrait de script suivant (dans le script d’apprentissage RemoveScriptMenuAction) :
#targetengine "session"
var mySampleScriptAction = app.scriptMenuActions.item("Display Message");
mySampleScriptAction.remove();
var mySampleScriptMenu = app.menus.item("$ID/Main").submenus.item
("Script Menu Action");
mySampleScriptMenu.remove();
Vous pouvez également supprimer tous les objets scriptMenuAction, comme l’illustre l’extrait de script
suivant (dans le script d’apprentissage RemoveAllScriptMenuActions). Ce script supprime également les
listes de menus de l’objet scriptMenuAction, mais il ne supprime pas les menus ou sous-menus que vous
avez créés.
#targetengine "session"
app.scriptMenuActions.everyItem().remove();
Vous pouvez créer une liste de tous les objets scriptMenuActions courants, comme l’illustre l’extrait de
script suivant (dans le script d’apprentissage GetScriptMenuActions) :
var myScriptMenuActionNames = app.scriptMenuActions.everyItem().name;
//Open a new text file.
var myTextFile = File.saveDialog("Save Script Menu Action Names As", undefined);
//If the user clicked the Cancel button, the result is null.
if(myTextFile != null){
//Open the file with write access.
myTextFile.open("w");
for(var myCounter = 0; myCounter < myScriptMenuActionNames.length; myCounter++){
myTextFile.writeln(myScriptMenuActionNames[myCounter]);
}
myTextFile.close();
}
L’objet scriptMenuAction peut également exécuter des scripts pendant l’événement event
beforeDisplay, auquel cas ils sont exécutés avant une demande interne de l’état de l’objet
scriptMenuAction (par exemple, lorsque l’élément de menu est sur le point d’être affiché). Ensuite, le
script peut notamment modifier le nom des menus et/ou définir l’état activé/coché.
Dans l’exemple de script suivant, un objet eventListener est ajouté à l’événement event beforeDisplay
qui vérifie la sélection en cours. En l’absence de sélection, le script dans l’objet eventListener désactive
l’élément de menu. Si un élément est sélectionné, celui-ci est activé, et la sélection de l’élément de menu
affiche le type du premier élément de la sélection. (Pour consulter le script complet, voir BeforeDisplay.)
var mySampleScriptAction = app.scriptMenuActions.add("Display Message");
var myEventListener = mySampleScriptAction.eventListeners.add("onInvoke",
myOnInvokeHandler, false);
var mySampleScriptMenu = app.menus.item("$ID/Main").submenus.add("Script Menu
Action");
var mySampleScriptMenuItem = mySampleScriptMenu.menuItems.add(mySampleScriptAction);
mySampleScriptMenu.eventListeners.add("beforeDisplay", myBeforeDisplayHandler,
false);
//JavaScript function to run before the menu item is drawn.
function myBeforeDisplayHandler(myEvent){
var mySampleScriptAction = app.scriptMenuActions.item("Display Message");
if(app.documents.length > 0){
if(app.selection.length > 0){
mySampleScriptAction.enabled = true;
}
Menus
Utilisation des objets d’action de menu de script
else{
mySampleScriptAction.enabled = false;
}
}
else{
mySampleScriptAction.enabled = false;
}
}
//JavaScript function to run when the menu item is selected.
function myOnInvokeHandler(myEvent){
myString = app.selection[0].constructor.name;
alert("The first item in the selection is a " + myString + ".");
}
75
7
Evénements
Statut de mise à jour du chapitre
CS6
Inchangé
Les scripts InCopy peuvent répondre aux événements d’application et de document courants, comme
l’ouverture d’un fichier, la création d’un fichier, l’impression et l’importation de fichiers texte et graphiques
à partir d’un disque. Avec les scripts InCopy, l’objet event répond à un événement qui se produit dans
l’application. Les scripts peuvent être associés aux événements par l’intermédiaire de l’objet de script
eventListener. Les scripts qui utilisent les événements sont identiques aux autres scripts, à la seule
différence près qu’ils sont exécutés automatiquement lorsque l’événement correspondant se produit, et
non manuellement par l’utilisateur (dans le panneau Scripts).
Ce chapitre décrit le mode d’utilisation des scripts d’événement InCopy. Les exemples de scripts de ce
chapitre sont présentés par ordre de complexité, en commençant par des scripts très simples et en
progressant vers des opérations plus complexes.
Vous devez avoir préalablement lu le Chapitre 2, « Prise en main » et savoir créer, installer et exécuter un
script.
Ce chapitre décrit les événements d’application et de document. Vous trouverez une description des
événements liés aux menus au Chapitre 6, « Menus ».
Le modèle de scripts d’événements InCopy est semblable à la recommandation W3C (Worldwide Web
Consortium) concernant les événements du modèle d’objet de document DOM (pour plus de détails,
visiter le site http://www.w3c.org).
Présentation du modèle de scripts d’événements
Le modèle de scripts d’événements InCopy comprend une série d’objets qui correspondent aux
événements survenant pendant l’utilisation de l’application. Le premier objet, event, correspond à l’une
des séries limitées d’actions dans l’interface utilisateur InCopy (ou des actions correspondantes
déclenchées par les scripts).
Pour répondre à un événement, vous devez enregistrer un objet eventListener avec un objet capable de
recevoir l’événement. Lorsque l’événement spécifié atteint l’objet, l’objet eventListener exécute la
fonction de script définie dans son gestionnaire (qui peut être une fonction de script ou une référence à un
fichier de script sur disque).
Le tableau suivant répertorie les événements auxquels l’objet eventListeners peut répondre. Ces
événements peuvent être déclenchés par n’importe quel moyen disponible, notamment les options de
menu sélectionnées, les raccourcis clavier ou les actions de script.
76
Evénements
Présentation du modèle de scripts d’événements
Evénement
d’interface
utilisateur
Nom de
l’événement
Description
Type d’objet
Se produit avant que le menu ou le
sous-menu ne s’affiche.
Event
beforeDisplay
Se produit avant que l’action de
menu du script ne s’affiche ou ne
change.
Event
beforeInvoke
Se produit après la sélection de
l’action de menu, mais avant son
exécution.
Event
afterInvoke
Se produit après l’exécution de
l’action de menu.
Event
onInvoke
Exécute l’action de menu ou l’action
de menu du script.
Event
beforeClose
Se produit après une demande de
fermeture de document, mais avant
que le document ne soit fermé.
DocumentEvent
afterClose
Se produit après la fermeture d’un
document.
DocumentEvent
beforeExport
Se produit après une demande
d’exportation, mais avant que le
document ou l’élément de page ne
soit exporté.
ImportExportEvent
afterExport
Se produit après l’exportation d’un
document ou d’un élément de page.
ImportExportEvent
beforeImport
Se produit avant qu’un fichier ne soit
importé, mais avant que le fichier ne
soit importé dans un document
(avant l’insertion).
ImportExportEvent
afterImport
Se produit après l’importation d’un
fichier, mais avant que le fichier ne
soit inséré dans une page.
ImportExportEvent
beforeNew
Se produit après une demande de
nouveau document, mais avant que
le document ne soit créé.
DocumentEvent
afterNew
Se produit après la création d’un
document.
DocumentEvent
beforeOpen
Se produit après une demande
DocumentEvent
d’ouverture de document, mais avant
que le document ne soit ouvert.
afterOpen
Se produit après l’ouverture d’un
document.
Toute action de beforeDisplay
menu
Fermer
Exporter
Importer
Nouveau
Ouvrir
DocumentEvent
77
Evénements
Présentation du modèle de scripts d’événements
Evénement
d’interface
utilisateur
Nom de
l’événement
Imprimer
beforePrint
Se produit après une demande
DocumentEvent
d’impression de document, mais avant
que le document ne soit imprimé.
afterPrint
Se produit après l’impression d’un
document.
DocumentEvent
beforeRevert
Se produit après une demande de
restauration d’un document, mais
avant que la version antérieure du
document ne soit restaurée.
DocumentEvent
afterRevert
Se produit après la restauration de la
version antérieure d’un document.
DocumentEvent
beforeSave
Se produit après une demande
DocumentEvent
d’enregistrement d’un document, mais
avant que le document ne soit enregistré.
afterSave
Se produit après l’enregistrement
d’un document.
DocumentEvent
beforeSaveACopy
Se produit après une demande
d’enregistrement d’une copie d’un
document, mais avant que le
document ne soit enregistré.
DocumentEvent
afterSaveACopy
Se produit après l’enregistrement
d’un document.
DocumentEvent
beforeSaveAs
Se produit après une demande
DocumentEvent
d’enregistrement sous un format, mais
avant que le document ne soit enregistré.
afterSaveAs
Se produit après l’enregistrement
d’un document.
Version
précédente
Enregistrer
Enregistrer une
copie
Enregistrer
sous
Description
78
Type d’objet
DocumentEvent
A propos des propriétés des événements et de la propagation des
événements
Lorsqu’une action, qu’elle soit exécutée par un utilisateur ou par un script, déclenche un événement, cet
événement peut s’étendre, ou se propager, aux objets de script capables d’y répondre. Lorsqu’un
événement atteint un objet ayant un objet eventListener enregistré pour cet événement, cet objet
eventListener est déclenché par l’événement. Un événement peut être traité par plusieurs objets à mesure
qu’il se propage.
Il existe trois types de propagation d’événement :
X
Aucune : seuls les objets eventListeners enregistrés avec la cible de l’événement sont déclenchés
par l’événement. L’événement beforeDisplay est l’exemple d’un événement qui ne se propage pas.
X
Capture : l’événement démarre au niveau supérieur du modèle d’objet de script, l’application, puis se
propage à travers le modèle jusqu’à la cible de l’événement. Tout objet eventListeners capable de
répondre à l’événement enregistré dans les objets au-dessus de la cible (target) traite l’événement.
Evénements
Présentation du modèle de scripts d’événements
X
79
Bouillonnement : l’événement démarre la propagation vers sa cible (target) et déclenche tout objet
eventListeners approprié enregistré avec la cible (target). L’événement se propage alors vers le
haut à travers le modèle d’objet de script, déclenchant les objets eventListeners appropriés qui sont
enregistrés avec les objets situés au-dessus de la cible (target) dans la hiérarchie du modèle d’objet
de script.
Le tableau suivant décrit de manière détaillée les propriétés d’un événement (event) et leurs relations
avant la propagation d’événement à travers le modèle d’objet de script.
Propriété
Description
Bubbles
Si elle est vraie (true), l’événement (event) se propage aux objets de script
situés au-dessus de l’objet déclenchant l’événement (event).
Cancelable
Si elle est vraie (true), le comportement par défaut de l’événement (event) sur sa
cible (target) peut être annulé. Pour cela, utilisez la méthode PreventDefault.
Captures
Si elle est vraie (true), l’événement (event) peut être traité par l’objet
eventListeners enregistré avec les objets de script situés au-dessus de l’objet
cible de l’événement au cours de la phase de capture de la propagation
d’événement. Cela signifie qu’un objet eventListener dans l’application, par
exemple, peut répondre à un événement de document avant qu’un objet
eventListener ne soit déclenché.
CurrentTarget
Objet de script actif traitant l’événement (event) (voir la propriété target dans
ce tableau).
DefaultPrevented
Si elle est vraie (true), le comportement par défaut de l’événement (event) sur
la cible (target) actuelle (voir la propriété target dans ce tableau) a été
bloqué, annulant ainsi l’opération.
EventPhase
Etape en cours du processus de propagation de l’événement (event).
EventType
Type d’événement (event), sous la forme d’une chaîne (par exemple, « beforeNew »).
PropagationStopped
Si elle est vraie (true), l’événement (event) a cessé de se propager au-delà de la
cible actuelle (current target) (voir la propriété target dans ce tableau). Pour
arrêter la propagation de l’événement, utilisez la méthode stopPropagation.
Target
Objet dont est issu l’événement (event). A titre d’exemple, la propriété target
(cible) d’un événement beforeImport est un document ; pour l’événement
beforeNew, il s’agit d’une application.
TimeStamp
Date et heure auxquelles l’événement (event) s’est produit.
Evénements
Utilisation des objets eventListeners 80
Utilisation des objets eventListeners
Lorsque vous créez un objet eventListener, vous spécifiez le type d’événement (sous forme de chaîne),
le gestionnaire d’événements (comme fonction JavaScript ou référence de fichier), et vous indiquez si
l’objet eventListener peut être déclenché dans la phase de capture de l’événement. L’extrait de script
suivant permet d’ajouter un objet eventListener pour un événement spécifique (pour consulter le script
complet, voir EventListener).
#targetengine "session"
main();
function main(){
var myEventListener = app.addEventListener("afterNew", myDisplayEventType,
false);
}
function myDisplayEventType(myEvent){
alert("This event is the " + myEvent.eventType + " event.");
}
Pour supprimer l’objet eventListener créé par le script ci-dessus, exécutez le script suivant (dans le script
d’apprentissage RemoveEventListener) :
app.removeEventListener("afterNew", myDisplayEventType, false);
Lorsqu’un objet eventListener répond à un événement, l’événement peut quand même être traité par
d’autres objets eventListeners qui peuvent surveiller l’événement (en fonction de la propagation de
l’événement). Par exemple, l’événement afterOpen peut être surveillé par l’objet eventListeners associé
à l’application et au document.
Les objets eventeventListeners ne sont plus valides au-delà de la session InCopy en cours. Pour
pouvoir utiliser un objet eventListener dans chaque session InCopy, ajoutez le script au dossier des
scripts de démarrage (pour plus de détails sur l’installation des scripts, voir le Chapitre 2, « Prise en main »).
Lorsque vous ajoutez un script eventListener à un document, il n’est pas enregistré avec le document, ni
exporté au format INX.
REMARQUE : si vous rencontrez des problèmes avec un script qui définit un objet eventListener, vous
pouvez soit exécuter un script qui supprime l’objet eventListener, soit fermer la session et
relancer InCopy.
Les objets eventListeners qui utilisent des fonctions de gestionnaire définies à l’intérieur du script (et
non dans un fichier externe) doivent utiliser #targetengine "session". Si le script est exécuté à l’aide de
#targetengine "main" (par défaut), la fonction n’est pas disponible lorsque l’événement se produit, et le
script génère une erreur.
Evénements
Utilisation des objets eventListeners 81
Un événement peut déclencher plusieurs objets eventListeners au cours de sa propagation à travers le
modèle d’objet de script. L’exemple de script suivant illustre un événement qui déclenche des objets
eventListeners enregistrés avec d’autres objets (pour consulter le script complet,
voir MultipleEventListeners) :
#targetengine "session"
main();
function main(){
var myApplicationEventListener = app.eventListeners.add("beforeImport",
myEventInfo, false);
var myDocumentEventListener = app.documents.item(0).eventListeners.add
("beforeImport", myEventInfo, false);
}
function myEventInfo(myEvent){
var myString = "Current Target: " + myEvent.currentTarget.name;
alert(myString);
}
Lorsque vous exécutez le script ci-dessus et que vous insérez un fichier, InCopy affiche des alertes
répertoriant, dans l’ordre, le nom du document, puis le nom de l’application.
L’exemple de script suivant crée un objet eventListener pour chaque événement pris en charge et
affiche des informations sur l’événement dans une boîte de dialogue simple. Pour consulter le script
complet, voir EventListenersOn.
main()
function main(){
app.scriptPreferences.version = 5.0;
var myEventNames = [
"beforeQuit", "afterQuit",
"beforeNew", "afterNew",
"beforeOpen", "afterOpen",
"beforeClose", "afterClose",
"beforeSave", "afterSave",
"beforeSaveAs", "afterSaveAs",
"beforeSaveACopy", "afterSaveACopy",
"beforeRevert", "afterRevert",
"beforePrint", "afterPrint",
"beforeExport", "afterExport",
"beforeImport", "afterImport"
] ;
for (var myCounter = 0; myCounter < myEventNames.length; myCounter ++){
app.addEventListener(myEventNames[myCounter], myEventInfo, false);
}
}
function myEventInfo(myEvent){
var myString = "Handling Event: " +myEvent.eventType;
myString += "\r\rTarget: " + myEvent.target + " " +myEvent.target.name;
myString += "\rCurrent: " +myEvent.currentTarget + " "
myStirng += myEvent.currentTarget.name;
myString += "\r\rPhase: " + myGetPhaseName(myEvent.eventPhase );
myString += "\rCaptures: " +myEvent.captures;
myString += "\rBubbles: " + myEvent.bubbles;
myString += "\r\rCancelable: " +myEvent.cancelable;
myString += "\rStopped: " +myEvent.propagationStopped;
myString += "\rCanceled: " +myEvent.defaultPrevented;
myString += "\r\rTime: " +myEvent.timeStamp;
alert(myString);
function myGetPhaseName(myPhase){
Evénements
Exemple d’objet eventListener « afterNew » 82
switch(myPhase){
case EventPhases.atTarget:
myPhaseName = "At Target";
break;
case EventPhases.bubblingPhase:
myPhaseName = "Bubbling";
break;
case EventPhases.capturingPhase:
myPhaseName = "Capturing";
break;
case EventPhases.done:
myPhaseName = "Done";
break;
case EventPhases.notDispatching:
myPhaseName = "Not Dispatching";
break;
}
return myPhaseName;
}
}
L’exemple de script suivant permet de désactiver tous les objets eventListeners pour l’objet
d’application. Pour consulter le script complet, voir EventListenersOff.
//EventListenersOff.jsx
//An InCopy CS6 JavaScript
#targetengine "session"
app.eventListeners.everyItem().remove();
Exemple d’objet eventListener « afterNew »
L’événement afterNew est pratique pour ajouter des informations au document, notamment le nom de
l’utilisateur, la date de création du document, les informations de copyright et toute autre information
de suivi. L’exemple de script suivant permet d’ajouter ce type d’information aux métadonnées d’un
document, également appelées informations de fichier ou informations XMP. Pour consulter le script
complet, voir le script d’apprentissage AfterNew.
#targetengine "session"
//Creates an event listener that will run after a new document is created.
main();
function main(){
var myEventListener = app.eventListeners.add("afterNew",
myAfterNewHandler, false);
}
function myAfterNewHandler(myEvent){
var myDocument = myEvent.parent;
main(myDocument);
function main(myDocument){
app.userName = "Adobe";
myAddXMPData(myDocument);
}
Evénements
Exemple d’objet eventListener « afterNew » 83
function myAddXMPData(myDocument){
with(myDocument.metadataPreferences){
author = "Adobe Systems";
description = "This is a sample document with XMP metadata. Created:"
+ myEvent.timeStamp + "\rby: " + app.userName;
}
}
}
8
Notes
Statut de mise à jour du chapitre
CS6
Inchangé
Grâce aux fonctions de notes d’édition en ligne d’InDesign et d’InCopy, vous pouvez ajouter des
commentaires et des remarques en tant que notes directement au texte sans que cela n’affecte le flux d’un
article. Les fonctions d’annotation sont conçues pour fonctionner dans un environnement de groupe de
travail. Vous pouvez coder les notes à l’aide de couleurs ou les désactiver selon certains critères.
Pour créer des notes, utilisez l’outil Note de la boîte à outils, la commande Notes > Nouvelle note ou l’icône
Nouvelle note du panneau Notes.
Vous devez avoir préalablement lu le Chapitre 2, « Prise en main » et savoir créer, installer et exécuter un
script. Vous devez également savoir manipuler les notes dans InCopy.
Saisie et importation d’une note
Cette section décrit le processus d’insertion d’une note dans vos documents InCopy. De la même manière
que vous pouvez créer une note et remplacer son texte à l’aide de l’interface utilisateur d’InCopy, vous
pouvez créer des notes et y insérer du texte à l’aide des scripts.
Ajout d’une note à un article
Pour ajouter une note à un article, utilisez la méthode add. L’exemple suivant ajoute une note au dernier
point d’insertion. Pour consulter le script complet, voir InsertNote.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Add note to a default story. We'll use the last insertion point in the story.
var myNote = myStory.insertionPoints.item(-1).notes.add();
//Add text to the note
myNote.texts.item(0).contents = "This is a note."
Remplacement du texte d’une note
Pour remplacer le texte d’une note, utilisez la propriété contents, comme illustré dans l’exemple suivant.
Pour consulter le script complet, voir Replace.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
var myNote = myStory.notes.item(0);
//Replace text of note with "This is a replaced note."
myNote.texts.item(0).contents = "This is a replaced note."
84
Notes
Conversion de notes et de texte 85
Conversion de notes et de texte
Conversion d’une note en texte
Pour convertir une note en texte, utilisez la méthode convertToText, comme illustré dans l’exemple
suivant. Pour consulter le script complet, voir ConvertToText.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Convert the note to text
myStory.notes.item(0).convertToText();
Conversion d’un texte en note
Pour convertir un texte en note, utilisez la méthode convertToNote, comme illustré dans l’exemple
suivant. Pour consulter le script complet, voir ConvertToNote.
var myDocument = app.documents.item(0);
myStory = myDocument.stories.item(0);
//Convert text to note
myStory.words.item(0).convertToNote();
Développement et réduction de notes
Réduction d’une note
L’extrait de script suivant montre comment réduire une note. Pour consulter le script complet,
voir CollapseNote.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
var myNote = myStory.notes.item(0);
//Collapse a note
myNote.collapsed = true;
Développement d’une note
L’extrait de script suivant montre comment développer une note. Pour consulter le script complet,
voir ExpandNote.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
var myNote = myStory.notes.item(0);
//Expand a note
myNote.collapsed = false;
Notes
Suppression d’une note
86
Suppression d’une note
Pour supprimer une note, utilisez la méthode remove, comme illustré dans l’exemple suivant. Pour
consulter le script complet, voir RemoveNote.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Remove the note
myStory.notes.item(0).remove(myStory.notes.item(0));
Navigation entre les notes
Accès à la première note d’un article
L’extrait de script suivant décrit comment accéder à la première note d’un article. Pour consulter le script
complet, voir FirstNote.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Get next note
var myNote = myStory.notes.firstItem();
//Add text to the note
myNote.texts.item(0).contents = "This is the first note."
Accès à la note suivante d’un article
L’extrait de script suivant décrit comment accéder à la note suivante d’un article. Pour consulter le script
complet, voir NextNote.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Get next note
var myNote = myStory.notes.nextItem(myStory.notes.item(0));
text to the note
myNote.texts.item(0).contents = "This is the next note."
Accès à la note précédente d’un article
L’extrait de script suivant décrit comment accéder à la note précédente d’un article. Pour consulter le script
complet, voir PreviousNote.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Get previous note
var myNote = myStory.notes.previousItem(myStory.notes.item(1));
//Add text to the note
myNote.texts.item(0).contents = "This is the prev note."
Notes
Navigation entre les notes
Accès à la dernière note d’un article
L’extrait de script suivant décrit comment accéder à la dernière note d’un article. Pour consulter le script
complet, voir LastNote.
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Get next note
var myNote = myStory.notes.lastItem();
//Add text to the note
myNote.texts.item(0).contents = "This is the last note."
87
9
Suivi des modifications
Statut de mise à jour du chapitre
CS6
Inchangé
Les rédacteurs peuvent suivre, afficher, masquer, accepter et rejeter des modifications à mesure qu’un
document progresse dans le processus de rédaction et d’édition. Toutes les modifications sont
enregistrées et visualisées pour faciliter la révision d’un document.
Ce chapitre décrit comment automatiser avec des scripts les opérations les plus courantes appliquées au
suivi des modifications.
Vous devez avoir préalablement lu le Chapitre 2, « Prise en main » et savoir créer, installer et exécuter un
script. Vous devez également savoir manipuler le texte dans InCopy et connaître la terminologie de base
du domaine de la composition.
Suivi des modifications
Cette section explique comment naviguer entre les modifications suivies, les accepter ou les rejeter à l’aide
des scripts.
Lorsqu’une personne ajoute, supprime ou déplace du texte dans un article, la modification est répercutée
dans les modes Epreuve en placard et Article.
Navigation entre les modifications suivies
Si l’article contient un enregistrement des modifications suivies, l’utilisateur peut les parcourir de façon
séquentielle. Les scripts suivants montrent comment naviguer entre les modifications.
Le script suivant utilise la méthode nextItem pour rechercher la modification qui suit le point d’insertion :
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Story.trackChanges
If true, track changes is turned on.
if(myStory.trackChanges==true )
{
var myChangeCount =myStory.changes.length;
var myChange = myStory.changes.item(0);
if(myChangeCount>1)
{
var myChange0 = myStory.changes.nextItem(myChange);
}
}
Dans le script suivant, nous utilisons la méthode previousItem pour rechercher la modification qui
précède le point d’insertion :
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
//Story.trackChanges
If true, track changes is turned on.
if(myStory.trackChanges==true )
{
88
Suivi des modifications
Suivi des modifications
89
var myChangeCount =myStory.changes.length;
var myChange = myStory.changes.lastItem();
if(myChangeCount>1)
{
var myChange0 = myStory.changes.previousItem(myChange);
}
}
Acceptation et rejet des modifications suivies
Lorsque vous (ou d’autres personnes) apportez une modification à un article, la fonction de suivi vous
permet de passer en revue toutes les modifications et de décider ou non de les intégrer à l’article. Vous
pouvez accepter et rejeter les modifications (texte ajouté, supprimé ou déplacé), effectuées par un autre
utilisateur.
Dans le script suivant, la modification est acceptée :
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
var myChange = myStory.changes.item(0);
myChange.accept () ;
Dans le script suivant, la modification est rejetée :
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
var myChange = myStory.changes.item(0);
myChange.reject() ;
Informations sur les modifications faisant l’objet d’un suivi
Ces informations incluent la date et l’heure de la modification. Le script suivant affiche des informations
sur une modification suivie :
var myDocument = app.documents.item(0);
var myStory = myDocument.stories.item(0);
var myChange = myStory.changes.item(0);
//ChangeTypes.DELETED_TEXT (Read Only) Deleted text.
//ChangeTypes.DELETED_TEXT (Read Only) Deleted text.
//ChangeTypes.MOVED_TEXT (Read Only) Moved text.
var myChangeTypes = myChange.changeType;
//Characters A collection of characters.
var myCharacters = myChange.characters;
//Character = myCharacters.item(0);
var myDate = myChange.date;
//InsertionPoints A collection of insertion points.
// insertpoint = myInsertionPoints.item(0);
var myInsertionPoints = myChange.insertionPoints;
//Change.lines (Read Only) A collection of lines.
var myLines = myChange.lines;
//Change.paragraphs (Read Only) A collection of paragraphs.
var myParagraphs =myChange.paragraphs;
//InsertionPoints A collection of insertion points.
// insertpoint = myInsertionPoints.item(0);
var myStoryOffset = myChange.storyOffset;
//Change.textColumns (Read Only) A collection of text columns.
var myTextColumns = myChange.textColumns;
//Change.textStyleRanges (Read Only) A collection of text style ranges.
Suivi des modifications
Préférences en matière de suivi des modifications
90
var myTextStyleRanges = myChange.textStyleRanges;
//Change.textVariableInstances (Read Only) A collection of text variable instances.
var myTextVariableInstances = myChange.textVariableInstances;
//Change.texts (Read Only) A collection of text objects.
var myTexts = myChange.texts;
var myUserName = myChange.userName;
var myWords = myChange.words;
Préférences en matière de suivi des modifications
Les préférences de suivi des modifications sont des paramètres destinés aux utilisateurs. Par exemple, vous
pouvez indiquer quelles modifications (ajout, suppression ou déplacement de texte) feront l’objet d’un
suivi. Vous pouvez préciser l’aspect de chaque type de modification suivie, mais aussi identifier les
changements par des barres de couleurs dans les marges. Le script suivant montre comment définir et
obtenir ces préférences :
var myTrackChangesPreference = app.trackChangesPreferences ;
with(myTrackChangesPreference)
{addedBackgroundColorChoice =
ChangeBackgroundColorChoices.CHANGE_BACKGROUND_USES_CHANGE_PREF_COLOR;
addedTextColorChoice = ChangeTextColorChoices.CHANGE_USES_CHANGE_PREF_COLOR ;
backgroundColorForAddedText = UIColors.gray;
var myColor = backgroundColorForDeletedText;
backgroundColorForDeletedText = UIColors.red;
backgroundColorForMovedText = UIColors.pink;
changeBarColor = UIColors.charcoal;
deletedBackgroundColorChoice
=ChangeBackgroundColorChoices.CHANGE_BACKGROUND_USES_CHANGE_PREF_COLOR;
deletedTextColorChoice =ChangeTextColorChoices.CHANGE_USES_CHANGE_PREF_COLOR ;
//ChangebarLocations.LEFT_ALIGN (Read Only) Change bars are in the left margin.
//ChangebarLocations.RIGHT_ALIGN (Read Only) Change bars are in the right margin
locationForChangeBar = ChangebarLocations.LEFT_ALIGN;
//ChangeMarkings.OUTLINE (Read Only)
Outlines changed text.
//ChangeMarkings.NONE (Read Only) Does not mark changed text.
//ChangeMarkings.STRIKETHROUGH (Read Only) Uses a strikethrough to mark changed
text.
//ChangeMarkings.UNDERLINE_SINGLE (Read Only) Underlines changed text.
markingForAddedText =ChangeMarkings.OUTLINE;
markingForDeletedText = ChangeMarkings.STRIKETHROUGH;
markingForMovedText = ChangeMarkings.UNDERLINE_SINGLE;
movedBackgroundColorChoice
=ChangeBackgroundColorChoices.CHANGE_BACKGROUND_USES_CHANGE_PREF_COLOR;
movedTextColorChoice = ChangeTextColorChoices.CHANGE_USES_CHANGE_PREF_COLOR ;
showAddedText = true;
shhowDeletedText =true;
showMovedText = true;
spellCheckDeletedtext = true;
showChangeBar = true;
textColorForAddedText=UIColors.blue;
textColorForDeletedText=UIColors.yellow;
textColorForMovedText=UIColors.green;
}
10
Affectations
Statut de mise à jour du chapitre
CS6
Inchangé
Une affectation est un conteneur pour le texte et les graphiques placé dans un fichier InDesign qui peut
être consulté et modifié dans InCopy. En général, une affectation contient du texte et des graphiques
associés, comme le corps du texte, les légendes et les illustrations qui composent un article de magazine.
Seule l’application InDesign permet de créer des affectations et des fichiers d’affectation.
Ce didacticiel explique comment automatiser par des scripts les opérations les plus courantes appliquées
aux affectations.
Vous devez avoir préalablement lu le Chapitre 2, « Prise en main » et savoir créer, installer et exécuter un script.
Objet affectation
Cette section explique comment travailler avec des affectations et des fichiers d’affectation. Grâce aux
scripts, vous pouvez ouvrir le fichier d’affectation et obtenir les propriétés d’affectation.
Ouverture des fichiers d’affectation
Le script suivant indique comment ouvrir un fichier d’affectation :
//Open an exist assignment file
var myDocument = app.open(File("/c/a.icma"));
var myAssignement = myDocument.assignments.item(0);
Itérations dans les propriétés d’affectation
L’extrait de script suivant indique comment obtenir les propriétés d’affectation, comme le nom
d’affectation, le nom d’utilisateur, l’emplacement du fichier d’affectation, ainsi que les options
d’exportation de l’affectation.
var myName = myAssignement.name;
var myUserName = myAssignement.userName;
var myDocument = app.documents.item(0);
var myAssignement = myDocument.assignments.item(0);
var myFilePath = myAssignement.filePath;
var myFramecolor = myAssignement.frameColor;
// exportOptions property can be:
// AssignmentExportOptions.ASSIGNED_SPREADS
// AssignmentExportOptions.EMPTY_FRAMES
// AssignmentExportOptions.EVERYTHING
var myExportOptions = myAssignement.exportOptions;
91
Affectations
Article d’affectation
92
Assemblages d’affectation
Les assemblages d’affectation (fichiers .incp créés par InCopy) sont des dossiers compressés qui
contiennent les fichiers d’affectation. Une affectation peut être assemblée à l’aide de la méthode
createPackage. L’exemple de script suivant utilise cette technique pour créer un fichier d’affectation :
var myDocument = app.documents.item(0);
var myAssignement = myDocument.assignments.item(0);
if(myAssignement.packaged==false)
{
var myFile= new File("/c/b.icap");
// PackageType.FORWARD_PACKAGE Creates an assignment package for export.
// PackageType.RETURN_PACKAGE Create a package to place in the main document.
myAssignement.createPackage(myFile,PackageType.FORWARD_PACKAGE);
}
Article d’affectation
Le diagramme suivant illustre un modèle d’objet affectation InCopy. Un document d’affectation contient
une ou plusieurs affectations ; une affectation ne contient aucun article ou peut en contenir au moins un.
Chaque article affecté contient une référence à un article de texte ou à un article d’image.
document
1
1…*
assignment
1
0…*
assigned story
1
1
text/image story
Cette section explique le processus d’obtention d’articles affectés et décrit les propriétés d’article d’affectation.
Objet article affecté
Le script suivant indique comment obtenir un article affecté à partir d’un objet affectation :
var myDocument = app.documents.item(0);
var myAssignement = myDocument.assignments.item(0);
var myAssignmentStory = myAssignement.assignedStories.item(0);
Affectations
Article d’affectation
93
Itérations dans les propriétés de l’article affecté
Dans InCopy, les objets article affecté ont des propriétés. Le script suivant indique comment obtenir toutes
les propriétés d’un objet article affecté :
var myDocument = app.documents.item(0);
var myAssignement = myDocument.assignments.item(0);
var myAssignmentStory = myAssignement.assignedStories.item(0);
if(myAssignmentStory != null)
{
var myName = myAssignmentStory.name;
var myIsvalid = myAssignmentStory.isValid;
var myFilePath = myAssignmentStory.filePath;
var myStoryReference = myAssignmentStory.storyReference;
}
11
XML
Statut de mise à jour du chapitre
CS6
Inchangé
XML (Extensible Markup Language) est un langage de balisage reposant sur le texte, créé et géré par le
groupe World Wide Web Consortium (www.w3.org). Comme le langage HTML (Hypertext Markup
Language), le langage XML utilise des chevrons pour délimiter les balises (par exemple, <article> ou
<para>). Le langage HTML comprend un ensemble prédéfini de balises, tandis que le langage XML permet
de décrire le contenu avec plus de précision en créant des balises personnalisées.
En raison de sa souplesse, le langage XML est de plus en plus utilisé comme format de stockage des
données. InCopy propose un ensemble complet de fonctions d’importation de données XML dans des
mises en page ; ces fonctions peuvent même être contrôlées à l’aide des scripts.
Vous devez avoir préalablement lu le Chapitre 2, « Prise en main » et savoir créer, installer et exécuter un
script. Vous devez également posséder une certaine connaissance des formats XML, DTD et XSLT.
Présentation
Comme le format XML concerne entièrement le contenu et non la mise en forme, son utilisation dans le
cadre d’une mise en page peut se révéler un véritable défi. La stratégie InCopy face à XML est complète et
souple, malgré un certain nombre de limites :
X
Une fois que les éléments XML sont importés dans un document InCopy, ils deviennent des
éléments InCopy qui correspondent à la structure XML. Les représentations InCopy des éléments XML
sont différentes des éléments XML proprement dits.
X
Chaque élément XML ne peut figurer qu’une seule fois dans une mise en page. Si vous souhaitez
dupliquer les informations de l’élément XML dans la mise en page, vous devez dupliquer
l’élément XML lui-même.
X
L’ordre d’affichage des éléments XML dans une mise en page dépend principalement de leur ordre
d’affichage dans la structure XML.
X
Tout texte qui s’affiche dans un article associé à un élément XML fait partie des données de cet
élément.
Meilleure méthode appliquée aux scripts XML dans InCopy
Il est conseillé d’effectuer la majorité des opérations sur un fichier XML à l’extérieur d’InCopy, avant
d’importer le fichier dans une mise en page InCopy. Ainsi, vous pouvez utiliser d’excellents outils, comme
les analyseurs et les éditeurs XML.
Si vous devez réorganiser ou dupliquer des éléments dans une structure de données XML importante,
le meilleur moyen consiste à transformer le format XML à l’aide du format XSLT. Cette opération s’effectue
pendant l’importation du fichier XML.
94
XML
Codage des éléments XML à l’aide des scripts
95
Codage des éléments XML à l’aide des scripts
Cette section décrit le mode de configuration des préférences générales XML et des préférences
d’importation XML, le mode d’importation du format XML, la création d’éléments XML et l’ajout
d’attributs XML. Les scripts de cette section illustrent les techniques d’utilisation du contenu XML ; vous
trouverez les scripts permettant d’appliquer des attributs de mise en forme aux éléments XML à la section
« Ajout d’éléments XML à un article » à la page 100.
Configuration des préférences XML
Vous pouvez définir l’aspect du panneau de la structure InCopy à l’aide de l’objet des préférences
d’affichage XML, comme l’indique l’extrait de script suivant (dans le script d’apprentissage
XMLViewPreferences) :
var myDocument = app.documents.add();
var myXMLViewPreferences = myDocument.xmlViewPreferences;
myXMLViewPreferences.showAttributes = true;
myXMLViewPreferences.showStructure = true;
myXMLViewPreferences.showTaggedFrames = true;
myXMLViewPreferences.showTagMarkers = true;
myXMLViewPreferences.showTextSnippets = true;
Vous pouvez également définir des préférences de balisage XML prédéfini (le nom des balises par défaut et
les couleurs de l’interface utilisateur pour les tableaux et les articles) à l’aide de l’objet des préférences XML,
comme l’illustre l’extrait de script suivant (dans le script d’apprentissage XMLPreferences) :
var myDocument = app.documents.add();
var myXMLPreferences = myDocument.xmlPreferences;
myXMLPreferences.defaultCellTagColor = UIColors.blue;
myXMLPreferences.defaultCellTagName = "cell";
myXMLPreferences.defaultImageTagColor = UIColors.brickRed;
myXMLPreferences.defaultImageTagName = "image";
myXMLPreferences.defaultStoryTagColor = UIColors.charcoal;
myXMLPreferences.defaultStoryTagName = "text";
myXMLPreferences.defaultTableTagColor = UIColors.cuteTeal;
myXMLPreferences.defaultTableTagName = "table";
Configuration des préférences d’importation du format XML
Avant d’importer un fichier XML, vous pouvez définir des préférences d’importation XML qui peuvent
appliquer une transformation XSLT, gérer les espaces dans le fichier XML ou créer des éléments de texte de
répétition. Pour cela, utilisez l’objet des préférences d’importation XML, comme l’illustre l’extrait de script
suivant (dans le script d’apprentissage XMLImportPreferences) :
var myDocument = app.documents.add();
var myXMLImportPreferences = myDocument.xmlImportPreferences;
myXMLImportPreferences.allowTransform = false;
myXMLImportPreferences.createLinkToXML = false;
myXMLImportPreferences.ignoreUnmatchedIncoming = true;
myXMLImportPreferences.ignoreWhitespace = true;
myXMLImportPreferences.importCALSTables = true;
myXMLImportPreferences.importStyle = XMLImportStyles.mergeImport;
myXMLImportPreferences.importTextIntoTables = false;
myXMLImportPreferences.importToSelected = false;
myXMLImportPreferences.removeUnmatchedExisting = false;
myXMLImportPreferences.repeatTextElements = true;
XML
Codage des éléments XML à l’aide des scripts
96
//The following properties are only used when the
//AllowTransform property is set to True.
//myXMLImportPreferences.transformFilename = "c:\myTransform.xsl"
//If you have defined parameters in your XSL file, then you can pass
//parameters to the file during the XML import process. For each parameter,
//enter an array containing two strings. The first string is the name of the
//parameter, the second is the value of the parameter.
//myXMLImportPreferences.transformParameters = [["format", "1"]];
Importation du format XML
Une fois que vous avez défini les préférences d’importation du format XML, vous pouvez importer un
fichier XML, comme l’illustre l’extrait de script suivant (dans le script d’apprentissage ImportXML) :
myDocument.importXML(File("/c/completeDocument.xml"));
Si vous devez importer le contenu d’un fichier XML dans un élément XML spécifique, utilisez la méthode
importXML de l’élément XML, à la place de la méthode correspondante du document. Voir l’extrait de
script suivant (dans le script d’apprentissage ImportXMLIntoElement) :
var myXMLTag = myDocument.xmlTags.add("xml_element");
var myXMLElement = myDocument.xmlElements.item(0).xmlElements.add(myXMLTag);
//Import into the new XML element.
myXMLElement.importXML(File("/c/completeDocument.xml"));
Vous pouvez également définir la propriété importToSelected de l’objet xmlImportPreferences sur
true (vrai), puis sélectionner l’élément XML et importer le fichier XML, comme l’illustre l’extrait de script
suivant (dans le script d’apprentissage ImportXMLIntoSelectedXMLElement) :
var myXMLTag = myDocument.xmlTags.add("xml_element");
var myXMLElement = myDocument.xmlElements.item(0).xmlElements.add(myXMLTag);
myDocument.select(myXMLElement);
myDocument.xmlImportPreferences.importToSelected = true;
//Import into the selected XML element.
myDocument.importXML(File("/c/test.xml"));
Création d’une balise XML
Les balises XML sont les noms des éléments XML à créer dans un document. Lorsque vous importez un
contenu au format XML, le nom des éléments présents dans le fichier XML est ajouté à la liste des
balises XML dans le document. Vous pouvez également créer directement des balises XML, comme
l’illustre l’extrait de script suivant (dans le script d’apprentissage MakeXMLTags) :
//You can create an XML tag without specifying a color for the tag.
var myXMLTagA = myDocument.xmlTags.add("XML_tag_A");
//You can define the highlight color of the XML tag using the UIColors enumeration...
var myXMLTagB = myDocument.xmlTags.add("XML_tag_B", UIColors.gray);
//...or you can provide an RGB array to set the color of the tag.
var myXMLTagC = myDocument.xmlTags.add("XML_tag_C", [0, 92, 128]);
XML
Codage des éléments XML à l’aide des scripts
97
Chargement des balises XML
Vous pouvez importer des balises XML à partir d’un fichier XML sans importer le contenu XML du fichier.
Cette opération peut être utile pour établir un mappage balise-style ou style-balise avant d’importer les
données XML, comme l’illustre l’extrait de script suivant (dans le script d’apprentissage LoadXMLTags) :
myDocument.loadXMLTags(File("/c/test.xml"));
Enregistrement des balises XML
Tout comme vous pouvez charger des balises XML à partir d’un fichier, vous pouvez enregistrer des
balises XML dans un fichier, comme l’illustre le script suivant. Seules les balises sont alors enregistrées dans
le fichier XML ; les données du document n’y sont pas incluses. Comme vous l’espériez sans doute, ce
processus est plus rapide que l’opération d’exportation du format XML, et le fichier généré est plus petit.
L’exemple de script suivant permet d’enregistrer les balises XML (pour consulter le script complet,
voir SaveXMLTags) :
myDocument.saveXMLTags(File("/c/xml_tags.xml"), "Tag set created October 5, 2006");
Création d’un élément XML
Normalement, vous créez des éléments XML en important un fichier XML, mais vous pouvez également
créer un élément XML à l’aide des scripts InCopy, comme l’illustre l’extrait de script suivant (dans le script
d’apprentissage CreateXMLElement) :
var myXMLTag = myDocument.xmlTags.add("myXMLTag");
var myRootElement = myDocument.xmlElements.item(0);
var myXMLElment = myRootElement.xmlElements.add(myXMLTag);
myXMLElement.contnets = "This is an XML element containing text."
Déplacement d’un élément XML
Vous pouvez déplacer des éléments XML dans la structure XML à l’aide de la méthode move, comme
l’illustre l’extrait de script suivant (dans le script d’apprentissage MoveXMLElement) :
var myDocument = app.documents.add();
var myRootXMLElement = myDocument.xmlElements.item(0);
var myXMLTag = myDocument.xmlTags.add("xml_element");
var myXMLElementA = myRootXMLElement.xmlElements.add(myXMLTag);
myXMLElementA.contents = "A";
var myXMLElementB = myRootXMLElement.xmlElements.add(myXMLTag);
myXMLElementB.contents = "B";
var myXMLElementC = myRootXMLElement.xmlElements.add(myXMLTag);
myXMLElementC.contents = "C";
var myXMLElementD = myRootXMLElement.xmlElements.add(myXMLTag);
myXMLElementD.contents = "D";
//Move the XML element containing "A" to after
//the XML element containing "C"
myXMLElementA.move(LocationOptions.after, myRootXMLElement.xmlElements.item(2));
//Move the XML element containing "D" to the beginning of its parent.
myRootXMLElement.xmlElements.item(-1).move(LocationOptions.atBeginning);
//Place the XML structure so that you can see the result.
myDocument.stories.item(0).placeXML(myRootXMLElement);
XML
Codage des éléments XML à l’aide des scripts
98
Suppression d’un élément XML
Un élément XML est supprimé à la fois de la mise en page et de la structure XML, comme l’illustre l’extrait
de script suivant (dans le script d’apprentissage DeleteXMLElement) :
myRootXMLElement.xmlElements.item(0).remove();
Duplication d’un élément XML
Lorsque vous dupliquez un élément XML, le nouvel élément XML s’affiche immédiatement après
l’élément XML d’origine dans la structure XML, comme l’illustre l’extrait de script suivant (dans le script
d’apprentissage DuplicateXMLElement) :
var myDocument = app.documents.item(0);
var myRootXMLElement = myDocument.xmlElements.item(0);
//Duplicate the XML element containing "A"
var myNewXMLElement = myRootXMLElement.xmlElements.item(0).duplicate();
//Change the content of the duplicated XML element.
myNewXMLElement.contents = myNewXMLElement.contents + " duplicate";
Retrait d’éléments de la structure XML
Pour annuler une association entre un objet texte et un élément XML, utilisez la méthode untag, comme
l’illustre le script suivant. Les objets ne sont pas supprimés, mais ils ne sont plus liés à un élément XML
(lequel est supprimé). Le contenu de l’élément XML supprimé est alors associé à l’élément XML parent.
Si l’élément XML est l’élément racine, les objets de mise en page (texte ou élément de page) associés à
l’élément XML restent dans le document. (Pour consulter le script complet, voir UntagElement.)
var myXMLElement = myDocument.xmlElements.item(0).xmlElements.item(-2);
myXMLElement.untag();
Création d’un commentaire XML
Les commentaires XML sont utilisés pour effectuer des annotations dans des structures de données XML.
Vous pouvez ajouter un commentaire XML en utilisant, par exemple, un script qui ressemble à l’extrait de
script suivant (dans le script d’apprentissage MakeXMLComment) :
var myRootXMLElement = myDocument.xmlElements.item(0);
var myXMLElement = myRootXMLElement.xmlElements.item(1);
myXMLElement.xmlComments.add("This is an XML comment.");
Création d’une instruction de traitement XML
Une instruction de traitement est un élément XML qui contient des indications pour l’application qui lit le
document XML. Les instructions de traitement XML sont ignorées par InCopy, mais elles peuvent être
insérées dans une structure XML InCopy pour être exportées dans d’autres applications. Un document XML
peut contenir plusieurs instructions de traitement.
Une instruction de traitement XML comprend deux parties : cible et valeur. Exemple d’instruction de
traitement XML :
<?xml-stylesheet type="text/css" href="generic.css"?>
XML
Codage des éléments XML à l’aide des scripts
99
L’extrait de script suivant permet d’ajouter une instruction de traitement XML (pour consulter le script
complet, voir MakeProcessingInstruction) :
var myRootXMLElement = myDocument.xmlElements.item(0);
var myXMLProcessingInstruction = myRootXMLElement.xmlInstructions.add("xml-stylesheet
type=\"text/css\" ", "href=\"generic.css\"");
Utilisation des attributs XML
Les attributs XML sont des « métadonnées » qui peuvent être associées à un élément XML. Pour ajouter un
attribut à un élément, utilisez un script qui ressemble à l’extrait suivant. Un élément XML peut comporter
un nombre quelconque d’attributs XML, mais chaque nom d’attribut doit être unique pour un même
élément (c’est-à-dire que vous ne pouvez pas avoir deux attributs nommés « id »).
L’extrait de script suivant permet d’ajouter un attribut XML à un élément XML (pour consulter le script
complet, voir MakeXMLAttribute) :
var myDocument = app.documents.item(0);
var myRootXMLElement = myDocument.xmlElements.item(0);
var myXMLElementB = myRootXMLElement.xmlElements.item(1);
myXMLElementB.xmlAttributes.add("example_attribute", "This is an XML attribute. It
will not appear in the layout!");
Outre la création d’attributs directement à l’aide des scripts, vous pouvez convertir les éléments XML
en attributs. Le contenu textuel de l’élément XML devient alors la valeur d’un attribut XML ajouté à
l’élément XML parent. Comme le nom de l’élément XML devient le nom de l’attribut, cette méthode peut
échouer si un attribut portant ce nom existe déjà dans l’élément XML parent. Si l’élément XML contient des
éléments de page, ils sont supprimés de la mise en page.
Lorsque vous convertissez un attribut XML en élément XML, vous pouvez spécifier l’emplacement où le
nouvel élément XML est ajouté. Le nouvel élément XML peut être ajouté au début ou à la fin de
l’attribut XML parent. Par défaut, le nouvel élément est ajouté au début de l’élément parent.
Vous pouvez également spécifier une balise de marquage XML pour le nouvel élément XML. Si vous
ignorez ce paramètre, le nouvel élément XML est créé avec la même balise XML que celle de l’élément XML
contenant l’attribut XML.
Le script suivant permet de convertir un élément XML en attribut XML (pour consulter le script complet,
voir le script d’apprentissage ConvertElementToAttribute) :
var myDocument = app.documents.add();
var myRootXMLElement = myDocument.xmlElements.item(0);
var myXMLTag = myDocument.xmlTags.add("myXMLElement");
var myXMLElement = myRootXMLElement.xmlElements.add(myXMLTag);
myXMLElement.contents = "This is content in an XML element.";
myXMLElement.convertToAttribute();
//Place the XML content so that you can see the result of the change.
var myStory = myDocument.stories.item(0);
myStory.placeXML(myRootXMLElement);
XML
Ajout d’éléments XML à un article
100
Vous pouvez également convertir un attribut XML en élément XML, comme l’illustre l’extrait de script
suivant (dans le script d’apprentissage ConvertAttributeToElement) :
var myRootXMLElement = myDocument.xmlElements.item(0);
var myXMLElementB = myRootXMLElement.xmlElements.item(1);
//The "at" parameter can be either LocationOptions.atEnd or
LocationOptions.atBeginning, but cannot
//be LocationOptions.after or LocationOptions.before.
myXMLElementB.xmlAttributes.item(0).convertToElement(XMLElementLocation.elementEnd,
myDocument.xmlTags.item("myXMLElement"));
Utilisation des articles XML
Lorsque vous importez des éléments XML qui ne sont pas associés à un élément de mise en page (article
ou élément de page), ils sont stockés dans un article XML. Vous pouvez utiliser le texte d’éléments XML
non placés, comme vous le feriez s’il s’agissait du texte d’un bloc. L’extrait de script suivant explique
comment procéder (pour consulter le script complet, voir XMLStory) :
var myXMLStory = myDocument.xmlStories.item(0);
//Though the text has not yet been placed in the layout, all text
//properties are available.
myXMLStory.texts.item(0).pointSize = 72;
//Place the XML element in the layout to see the result.
myDocument.xmlElements.item(0).xmlElements.item(0).placeXML(myDocument.pages.item(0).
textFrames.item(0));
Exportation du format XML
Pour exporter des données XML à partir d’un document InCopy, exportez la structure XML entière dans le
document ou un élément XML (y compris les éléments XML enfants qu’il contient). L’extrait de script
suivant montre comment procéder (pour consulter le script complet, voir ExportXML) :
myDocument.exportFile("XML", File("/c/test.xml")
Ajout d’éléments XML à un article
Précédemment, nous avons étudié le processus d’importation des données XML dans les documents
InCopy et l’utilisation de la structure XML dans un document. Dans cette section, nous allons aborder les
techniques d’importation des données XML dans un article et l’application d’attributs de mise en forme.
Association d’éléments XML à du texte
Pour associer un texte à un élément XML existant, utilisez la méthode placeXML. Elle consiste à remplacer
le contenu de l’élément de page par le contenu de l’élément XML, comme l’illustre l’extrait de script suivant
(dans le script d’apprentissage PlaceXML) :
myDocument.stories.item(0).placeXML(xmlElements.item(0);
Pour associer un objet texte existant à un élément XML existant, utilisez la méthode markup. Elle consiste à
fusionner le contenu de l’élément XML (le cas échéant) avec le contenu de l’objet texte. L’extrait de script
suivant illustre l’utilisation de la méthode markup (pour consulter le script complet, voir Markup) :
XML
Ajout d’éléments XML à un article
101
var myDocument = app.documents.add();
var myRootXMLElement = myDocument.xmlElements.item(0);
var myStory = myDocument.stories.item(0);
myStory.placeXML(myRootXMLElement);
myString = "This is the first paragraph in the story.\r";
myString += "This is the second paragraph in the story.\r";
myString += "This is the third paragraph in the story.\r";
myString += "This is the fourth paragraph in the story.\r";
myStory.contents = myString;
var myXMLTag = myDocument.xmlTags.add("myXMLlement");
var myXMLElement = myRootXMLElement.xmlElements.add(myXMLTag);
myStory.paragraphs.item(2).markup(myXMLElement);
Insertion d’un texte dans et autour des éléments de texte XML
Lorsque vous insérez des données XML dans un article InCopy, vous devez souvent ajouter des espaces
(par exemple, des caractères de retour chariot et de tabulation) et du texte statique (étiquettes « nom » ou
« adresse ») au texte des éléments XML. L’exemple de script suivant permet d’ajouter du texte à l’intérieur
et autour des éléments XML (pour consulter le script complet, voir InsertTextAsContent) :
var myXMLElement = myDocument.xmlElements.item(0).xmlElements.item(0);
//By inserting the return character after the XML element, the character
//becomes part of the content of the parent XML element, not of the element itself.
myXMLElement.insertTextAsContent("\r", XMLElementPosition.afterElement);
myXMLElement = myDocument.xmlElements.item(0).xmlElements.item(1);
myXMLElement.insertTextAsContent("Static text: ", XMLElementPosition.beforeElement);
myXMLElement.insertTextAsContent("\r", XMLElementPosition.afterElement);
//To add text inside the element, set the location option to beginning or end.
myXMLElement = myDocument.xmlElements.item(0).xmlElements.item(2);
myXMLElement.insertTextAsContent("Text at the start of the element: ",
XMLElementPosition.elementStart);
myXMLElement.insertTextAsContent(" Text at the end of the element.",
XMLElementPosition.elementEnd);
myXMLElement.insertTextAsContent("\r", XMLElementPosition.afterElement);
//Add static text outside the element.
myXMLElement = myDocument.xmlElements.item(0).xmlElements.item(3);
myXMLElement.insertTextAsContent("Text before the element: ",
XMLElementPosition.beforeElement);
myXMLElement.insertTextAsContent(" Text after the element.",
XMLElementPosition.afterElement);
//To insert text inside the text of an element, work with the text
//objects contained by the element.
myXMLElement.words.item(2).insertionPoints.item(0).contents = "(the third word of) ";
Mappage des balises aux styles
Le moyen le plus rapide d’appliquer une mise en forme aux éléments de texte XML est de recourir à la
méthode xmlImportMaps, appelée également mappage balise-style. Vous pouvez alors associer une
balise XML spécifique à un style de paragraphe ou de caractère. Lorsque vous utilisez la
méthode mapTagsToStyles du document, InCopy applique le style au texte, comme l’illustre l’extrait de
script suivant (dans le script d’apprentissage MapTagsToStyles) :
var myDocument = app.documents.item(0);
//Create a tag to style mapping.
myDocument.xmlImportMaps.add(myDocument.xmlTags.item("heading_1"),
myDocument.paragraphStyles.item("heading 1"));
myDocument.xmlImportMaps.add(myDocument.xmlTags.item("heading_2"),
XML
Ajout d’éléments XML à un article
102
myDocument.paragraphStyles.item("heading 2"));
myDocument.xmlImportMaps.add(myDocument.xmlTags.item("para_1"),
myDocument.paragraphStyles.item("para 1"));
myDocument.xmlImportMaps.add(myDocument.xmlTags.item("body_text"),
myDocument.paragraphStyles.item("body text"));
//Apply the tag to style mapping.
myDocument.mapXMLTagsToStyles();
//Place the XML element in the layout to see the result.
myDocument.stories.item(0).placeXML(myDocument.xmlElements.item(0));
Mappage des styles aux balises
Lorsque vous avez mis en forme un texte qui n’est pas associé à des éléments XML, et que vous souhaitez
placer ce texte dans une structure XML, utilisez le mappage style-balise pour associer les styles de
paragraphe et de caractère aux balises XML. Pour cela, utilisez les objets xmlExportMaps pour créer les liens
entre les balises et les styles XML, puis utilisez la méthode mapStylesToTags pour créer les éléments XML
correspondants, comme l’illustre l’extrait de script suivant (dans le script d’apprentissage MapStylesToTags) :
var myDocument = app.documents.item(0);
//Create a style to tag mapping.
myDocument.xmlExportMaps.add(myDocument.paragraphStyles.item("heading 1"),
myDocument.xmlTags.item("heading_1"));
myDocument.xmlExportMaps.add(myDocument.paragraphStyles.item("heading 2"),
myDocument.xmlTags.item("heading_2"));
myDocument.xmlExportMaps.add(myDocument.paragraphStyles.item("para 1"),
myDocument.xmlTags.item("para_1"));
myDocument.xmlExportMaps.add(myDocument.paragraphStyles.item("body text"),
myDocument.xmlTags.item("body_text"));
//Apply the style to tag mapping.
myDocument.mapStylesToXMLTags();
Une autre méthode consiste tout simplement à utiliser le script pour créer une nouvelle balise XML pour
chacun des styles de paragraphe ou de caractère du document, puis à appliquer le mappage style-balise,
comme l’illustre l’extrait de script suivant (dans le script d’apprentissage MapAllStylesToTags) :
var myDocument = app.documents.item(0);
//Create tags that match the style names in the document,
//creating an XMLExportMap for each tag/style pair.
for(var myCounter = 0; myCounter<myDocument.paragraphStyles.length; myCounter++){
var myParagraphStyle = myDocument.paragraphStyles.item(myCounter);
var myParagraphStyleName = myParagraphStyle.name;
var myXMLTagName = myParagraphStyleName.replace(/\ /gi, "_")
myXMLTagName = myXMLTagName.replace(/\[/gi, "")
myXMLTagName = myXMLTagName.replace(/\]/gi, "")
var myXMLTag = myDocument.xmlTags.add(myXMLTagName);
myDocument.xmlExportMaps.add(myParagraphStyle, myXMLTag);
}
//Apply the tag to style mapping.
myDocument.mapStylesToXMLTags();
XML
Ajout d’éléments XML à un article
103
Application des styles aux éléments XML
Outre l’utilisation des mappages balise-style et style-balise ou l’application des styles au texte et aux
éléments de page associés aux éléments XML, vous pouvez également appliquer directement des styles
aux éléments XML. Le fragment de script suivant vous montre comment utiliser les méthodes
applyParagraphStyle et applyCharacterStyle. (Pour consulter le script complet,
voir ApplyStylesToXMLElements.)
var myDocument = app.documents.add();
myDocument.viewPreferences.horizontalMeasurementUnits = MeasurementUnits.points;
myDocument.viewPreferences.verticalMeasurementUnits = MeasurementUnits.points;
//Create a series of XML tags.
var myHeading1XMLTag = myDocument.xmlTags.add("heading_1");
var myHeading2XMLTag = myDocument.xmlTags.add("heading_2");
var myPara1XMLTag = myDocument.xmlTags.add("para_1");
var myBodyTextXMLTag = myDocument.xmlTags.add("body_text");
//Create a series of paragraph styles.
var myHeading1Style = myDocument.paragraphStyles.add();
myHeading1Style.name = "heading 1";
myHeading1Style.pointSize = 24;
var myHeading2Style = myDocument.paragraphStyles.add();
myHeading2Style.name = "heading 2";
myHeading2Style.pointSize = 14;
myHeading2Style.spaceBefore = 12;
var myPara1Style = myDocument.paragraphStyles.add();
myPara1Style.name = "para 1";
myPara1Style.pointSize = 12;
myPara1Style.firstLineIndent = 0;
var myBodyTextStyle = myDocument.paragraphStyles.add();
myBodyTextStyle.name = "body text";
myBodyTextStyle.pointSize = 12;
myBodyTextStyle.firstLineIndent = 24;
//Create a character style.
var myCharacterStyle = myDocument.characterStyles.add();
myCharacterStyle.name = "Emphasis";
myCharacterStyle.fontStyle = "Italic";
//Add XML elements and apply paragraph styles.
var myRootXMLElement = myDocument.xmlElements.item(0);
var myXMLElementA = myRootXMLElement.xmlElements.add(myHeading1XMLTag);
myXMLElementA.contents = "Heading 1";
myXMLElementA.insertTextAsContent("\r", XMLElementPosition.afterElement);
myXMLElementA.applyParagraphStyle(myHeading1Style, true);
var myXMLElementB = myRootXMLElement.xmlElements.add(myPara1XMLTag);
myXMLElementB.contents = "This is the first paragraph in the article.";
myXMLElementB.insertTextAsContent("\r", XMLElementPosition.afterElement);
myXMLElementB.applyParagraphStyle(myPara1Style, true);
var myXMLElementC = myRootXMLElement.xmlElements.add(myBodyTextXMLTag);
myXMLElementC.contents = "This is the second paragraph in the article.";
myXMLElementC.insertTextAsContent("\r", XMLElementPosition.afterElement);
myXMLElementC.applyParagraphStyle(myBodyTextStyle, true);
var myXMLElementD = myRootXMLElement.xmlElements.add(myHeading2XMLTag);
myXMLElementD.contents = "Heading 2";
myXMLElementD.insertTextAsContent("\r", XMLElementPosition.afterElement);
myXMLElementD.applyParagraphStyle(myHeading2Style, true);
var myXMLElementE = myRootXMLElement.xmlElements.add(myPara1XMLTag);
myXMLElementE.contents = "This is the first paragraph following the subhead.";
myXMLElementE.insertTextAsContent("\r", XMLElementPosition.afterElement);
myXMLElementE.applyParagraphStyle(myPara1Style, true);
var myXMLElementF = myRootXMLElement.xmlElements.add(myBodyTextXMLTag);
XML
Ajout d’éléments XML à un article
104
myXMLElementF.contents = "This is the second paragraph following the subhead.";
myXMLElementF.insertTextAsContent("\r", XMLElementPosition.afterElement);
myXMLElementF.applyParagraphStyle(myBodyTextStyle, true);
var myXMLElementG = myRootXMLElement.xmlElements.add(myBodyTextXMLTag);
myXMLElementG.contents = "Note:";
myXMLElementG = myXMLElementG.move(LocationOptions.atBeginning, myXMLElementF)
myXMLElementG.insertTextAsContent(" ", XMLElementPosition.afterElement);
myXMLElementG.applyCharacterStyle(myCharacterStyle, true);
// Associate the root XML element with the story.
myDocument.stories.item(0).placeXML(myRootXMLElement);
Utilisation des tableaux XML
InCopy importe automatiquement les données XML dans les cellules du tableau lorsque les données sont
balisées à l’aide du marquage de tableau standard HTML. Si vous ne pouvez pas ou préférez ne pas utiliser
le balisage de tableau par défaut, InCopy permet de convertir les éléments XML en tableau à l’aide de la
méthode convertElementToTable.
Pour utiliser cette méthode, les éléments XML à convertir en tableau doivent être conformes à une structure
spécifique. Chaque rangée du tableau doit correspondre à un élément XML spécifique, et cet élément doit
contenir une série d’éléments XML correspondant aux cellules de la rangée. L’extrait de script suivant explique
comment utiliser cette méthode (pour consulter le script complet, voir ConvertXMLElementToTable).
L’élément XML utilisé pour désigner la rangée du tableau est utilisé par ce processus.
var myDocument = app.documents.add();
//Create a series of XML tags.
var myRowTag = myDocument.xmlTags.add("row");
var myCellTag = myDocument.xmlTags.add("cell");
var myTableTag = myDocument.xmlTags.add("table");
//Add XML elements.
var myRootXMLElement = myDocument.xmlElements.item(0);
with(myRootXMLElement){
var myTableXMLElement = xmlElements.add(myTableTag);
with(myTableXMLElement){
for(var myRowCounter = 1;myRowCounter < 7;myRowCounter++){
with(xmlElements.add(myRowTag)){
myString = "Row " + myRowCounter;
for(var myCellCounter = 1; myCellCounter < 5; myCellCounter++){
with(xmlElements.add(myCellTag)){
contents = myString + ":Cell " + myCellCounter;
}
}
}
}
}
}
var myTable = myTableXMLElement.convertElementToTable(myRowTag, myCellTag);
var myStory = myDocument.stories.item(0);
myStory.placeXML(myDocument.xmlElements.item(0));
XML
Ajout d’éléments XML à un article
105
Une fois que vous utilisez un tableau contenant des éléments XML, vous pouvez appliquer directement des
styles de tableau et de cellule aux éléments XML, au lieu d’appliquer les styles aux tableaux ou aux cellules
associés aux éléments XML. Pour cela, utilisez les méthodes applyTableStyle et applyCellStyle, comme
l’illustre l’extrait de script suivant (dans le script d’apprentissage ApplyTableStyle) :
var myDocument = app.documents.add();
//Create a series of XML tags.
var myRowTag = myDocument.xmlTags.add("row");
var myCellTag = myDocument.xmlTags.add("cell");
var myTableTag = myDocument.xmlTags.add("table");
//Create a table style and a cell style.
var myTableStyle = myDocument.tableStyles.add({name:"myTableStyle"});
myTableStyle.startRowFillColor = myDocument.colors.item("Black");
myTableStyle.startRowFillTint = 25;
myTableStyle.endRowFillColor = myDocument.colors.item("Black");
myTableStyle.endRowFillTint = 10;
var myCellStyle = myDocument.cellStyles.add();
myCellStyle.fillColor = myDocument.colors.item("Black");
myCellStyle.fillTint = 45
//Add XML elements.
var myRootXMLElement = myDocument.xmlElements.item(0);
with(myRootXMLElement){
var myTableXMLElement = xmlElements.add(myTableTag);
with(myTableXMLElement){
for(var myRowCounter = 1;myRowCounter < 7;myRowCounter++){
with(xmlElements.add(myRowTag)){
myString = "Row " + myRowCounter;
for(var myCellCounter = 1; myCellCounter < 5; myCellCounter++){
with(xmlElements.add(myCellTag)){
contents = myString + ":Cell " + myCellCounter;
}
}
}
}
}
}
var myTable = myTableXMLElement.convertElementToTable(myRowTag, myCellTag);
var myTableXMLElement = myDocument.xmlElements.item(0).xmlElements.item(0);
myTableXMLElement.applyTableStyle(myTableStyle);
myTableXMLElement.xmlElements.item(0).applyCellStyle(myCellStyle);
myTableXMLElement.xmlElements.item(5).applyCellStyle(myCellStyle);
myTableXMLElement.xmlElements.item(10).applyCellStyle(myCellStyle);
myTableXMLElement.xmlElements.item(15).applyCellStyle(myCellStyle);
myTableXMLElement.xmlElements.item(16).applyCellStyle(myCellStyle);
myTableXMLElement.xmlElements.item(21).applyCellStyle(myCellStyle);
myDocument.stories.item(0).placeXML(myDocument.xmlElements.item(0));
myTable.alternatingFills = AlternatingFillsTypes.alternatingRows;