Introduce un elemento raíz <mei> en el editor de abajo. No olvides cerrar la etiqueta de apertura con la correspondiente etiqueta de cierre.
- P.D.: En los próximos pasos trataremos algunos principios básicos de XML. Para más información, puedes consultar las muchas fuentes disponibles en la web, por ejemplo, la Gentle Introduction to XML (Ligera introducción al XML) de la Text Encoding Initative (TEI).
+ P.D.: En los próximos pasos trataremos algunos principios básicos de XML.
+ Para más información, puedes consultar las muchas fuentes disponibles en
+ la web, por ejemplo, la
+
+ Gentle Introduction to XML (Ligera introducción al XML) de la Text Encoding Initative (
+ TEI).
diff --git a/_tutorials-FR/100_structure/100_Structure.md b/_tutorials-FR/100_structure/100_Structure.md
new file mode 100644
index 00000000..4c90abaf
--- /dev/null
+++ b/_tutorials-FR/100_structure/100_Structure.md
@@ -0,0 +1,7 @@
+---
+layout: tutorials-FR
+type: tutorial-FR
+name: "DÉBUTANT : Les bases de XML et la structure minimale de la MEI"
+fullname: "Un court tutoriel sur les bases XML de la MEI"
+data: "100_structure.json"
+---
diff --git a/_tutorials-FR/100_structure/100_structure.json b/_tutorials-FR/100_structure/100_structure.json
new file mode 100644
index 00000000..8308bbb4
--- /dev/null
+++ b/_tutorials-FR/100_structure/100_structure.json
@@ -0,0 +1,81 @@
+{
+ "steps": [
+ {
+ "label":"Bienvenue dans la MEI",
+ "descFile": "100_structure_step-00-desc.html"
+ },
+ {
+ "label": "L'élément racine de la MEI",
+ "editorLines": 1,
+ "descFile": "100_structure_step-01-desc.html",
+ "prefillFile": "100_structure_step-01-prefill.xml",
+ "xmlFile": "100_structure_step-01.xml",
+ "xpaths": [
+ {"rule": "count(//mei) = 1", "renderanyway": true, "hint": "You need one mei element."}
+ ]
+ },
+ {
+ "label": "Le namespace MEI",
+ "editorLines": 1,
+ "descFile": "100_structure_step-02-desc.html",
+ "prefillFile": "100_structure_step-02-prefill.xml",
+ "xmlFile": "100_structure_step-02.xml",
+ "xpaths": [
+ {"rule": "count(*[local-name()='mei']) = 1", "renderanyway": true, "hint": "You need one mei element."},
+ {"rule": "*[local-name()='mei' and namespace-uri()='http://www.music-encoding.org/ns/mei']", "renderanyway": true, "hint": "You need a @xmlns declaration with the mei namespace 'http://www.music-encoding.org/ns/mei'."}
+ ]
+ },
+ {
+ "label": "Les deux éléments enfants de base",
+ "editorLines": 4,
+ "descFile": "100_structure_step-03-desc.html",
+ "prefillFile": "100_structure_step-03-prefill.xml",
+ "xmlFile": "100_structure_step-03.xml",
+ "xpaths": [
+ {"rule": "count(//*[local-name()='mei']) = 1", "renderanyway": false, "hint": "You need one mei element."},
+ {"rule": "*[local-name()='mei' and namespace-uri()='http://www.music-encoding.org/ns/mei']", "renderanyway": true, "hint": "You need a @xmlns declaration with the mei namespace 'http://www.music-encoding.org/ns/mei' in the mei element."},
+ {"rule": "count(//*[local-name()='meiHead']) = 1", "renderanyway": false, "hint": "You need one meiHead element."},
+ {"rule": "//*[local-name()='mei']/*[local-name()='meiHead']", "renderanyway": false, "hint": "meiHead has to a be child of the mei element."},
+ {"rule": "count(//*[local-name()='music']) = 1", "renderanyway": false, "hint": "You need one music element."},
+ {"rule": "//*[local-name()='mei']/*[local-name()='music']", "renderanyway": false, "hint": "music has to a be child of the mei element."},
+ {"rule": "//*[local-name()='mei']/*[local-name()='meiHead']/following-sibling::*[local-name()='music']", "renderanyway": false, "hint": "music has to follow the meiHead element."}
+ ]
+ },
+ {
+ "label": "L'en-tête MEI minimal",
+ "editorLines": 11,
+ "descFile": "100_structure_step-04-desc.html",
+ "prefillFile": "100_structure_step-04-prefill.xml",
+ "xmlFile": "100_structure_step-04.xml",
+ "xpaths": [
+ {"rule": "count(//*[local-name()='mei']) = 1", "renderanyway": false, "hint": "You need one mei element."},
+ {"rule": "*[local-name()='mei' and namespace-uri()='http://www.music-encoding.org/ns/mei']", "renderanyway": true, "hint": "You need a @xmlns declaration with the mei namespace 'http://www.music-encoding.org/ns/mei' in the mei element."},
+ {"rule": "count(//*[local-name()='meiHead']) = 1", "renderanyway": false, "hint": "You need one meiHead element."},
+ {"rule": "//*[local-name()='mei']/*[local-name()='meiHead']", "renderanyway": false, "hint": "meiHead has to be a child of the mei element."},
+ {"rule": "count(//*[local-name()='music']) = 1", "renderanyway": false, "hint": "You need one music element."},
+ {"rule": "//*[local-name()='mei']/*[local-name()='music']", "renderanyway": false, "hint": "music has to be a child of the mei element."},
+ {"rule": "//*[local-name()='mei']/*[local-name()='meiHead']/following-sibling::*[local-name()='music']", "renderanyway": false, "hint": "music has to follow the meiHead element."},
+ {"rule": "count(//*[local-name()='fileDesc']) = 1", "renderanyway": false, "hint": "You need one fileDesc element."},
+ {"rule": "//*[local-name()='meiHead']/*[local-name()='fileDesc']", "renderanyway": false, "hint": "fileDesc has to be a child of the meiHead element."},
+ {"rule": "count(//*[local-name()='titleStmt']) = 1", "renderanyway": false, "hint": "You need one titleStmt element."},
+ {"rule": "//*[local-name()='fileDesc']/*[local-name()='titleStmt']", "renderanyway": false, "hint": "titleStmt has to be a child of the fileDesc element."},
+ {"rule": "count(//*[local-name()='pubStmt']) = 1", "renderanyway": false, "hint": "You need one pubStmt element."},
+ {"rule": "//*[local-name()='fileDesc']/*[local-name()='pubStmt']", "renderanyway": false, "hint": "pubStmt has to be a child of the fileDesc element."},
+ {"rule": "//*[local-name()='fileDesc']/*[local-name()='titleStmt']/following-sibling::*[local-name()='pubStmt']", "renderanyway": false, "hint": "pubStmt has to follow the titleStmt element."},
+ {"rule": "count(//*[local-name()='title']) = 1", "renderanyway": false, "hint": "You need one title element."},
+ {"rule": "//*[local-name()='titleStmt']/*[local-name()='title']", "renderanyway": false, "hint": "title has to be a child of the titleStmt element."}
+ ]
+ }
+ ],
+ "end": "100_structure_end.html",
+ "resp":[
+ {
+ "name":"Stefan Münnich",
+ "affiliation":"Anton Webern Gesamtausgabe | University of Basel"
+ },
+ {
+ "name":"Johannes Kepper",
+ "affiliation":"Beethovens Werkstatt | Universität Paderborn"
+ }
+ ]
+}
diff --git a/_tutorials-FR/100_structure/100_structure_end.html b/_tutorials-FR/100_structure/100_structure_end.html
new file mode 100644
index 00000000..9efac5e8
--- /dev/null
+++ b/_tutorials-FR/100_structure/100_structure_end.html
@@ -0,0 +1,28 @@
+
+
Félicitations!
+
+ Vous venez d'écrire un fichier MEI valide et avez terminé avec succès ce tutoriel. Vous devriez maintenant être en mesure de :
+
+
comprendre les principes de base de XML et comment il sert de base à MEI
+
identifier et rédiger la structure de base la plus extérieur d'un document conforme à MEI, y compris son titre
+
différencier les deux principales sections d'un fichier MEI, celle responsables des informations de métadonnées
+ (<meiHead>) et celle responsable des informations sur le contenu musical (<music>).
+
+
+ Étant donné que les sujets abordés dans ce tutoriel renvoient au chapitre Éléments structurels des directives MEI,
+ nous vous recommandons de consulter ce chapitre dans le cas de besoin d'informations plus détaillées.
+
+
+ Bien sûr, ce tutoriel n'étant qu'une introduction, il vous manque encore beaucoup d'informations pour créer un fichier MEI complet - nous avons omis toutes les informations sur le contenu musical telles que les mesures, les portées ou les notes, et vous devez
+ également apprendre à configurer la mesure, la tonalité et les clefs.
+ Voici quelques autres tutoriels que nous aimerions vous recommander comme étapes suivantes pour votre apprentissage. Vous pourrez toujours y revenir (et même à celui-ci) lorsque vous souhaiterez vous rappeler comment faire certaines choses en MEI.
+
+
+ Dès que vous vous serez bien familiarisé avec la MEI, nous vous invitons à partager votre expérience avec la Communauté MEI
+ et, pourquoi pas, à rédiger vous-même un tutoriel sur un aspect de la MEI qui vous intéresse particulièrement. Vous n'avez pas besoin d'être un expert pour cela - il est bon d'avoir des tutoriels à différents niveaux. Très souvent un tutoriel rédigé par d'autres débutants qui viennent de maîtriser une tâche
+ est plus facile à suivre qu'un guide écrit par une personne plus experimenté qui, ayant complètement assimilé certains éléments, ne se souvient pas qu'ils aient pu être difficile à comprendre des éléments.
+ Nous avons un tutoriel sur la rédaction de tutoriels,
+ et nous proposons des modèles à suivre. C'est facile de devenir un membre actif de la Communauté MEI :)
+
+
+
\ No newline at end of file
diff --git a/_tutorials-FR/100_structure/step-00/100_structure_step-00-desc.html b/_tutorials-FR/100_structure/step-00/100_structure_step-00-desc.html
new file mode 100644
index 00000000..156bc21e
--- /dev/null
+++ b/_tutorials-FR/100_structure/step-00/100_structure_step-00-desc.html
@@ -0,0 +1,32 @@
+
+
+ Dans ce tutoriel, vous vous familiariserez avec l'organisation de base d'un
+ langage XML et apprendrez à concevoir la structure d'un fichier MEI valide.
+ Vous apprendrez à en identifier les différentes parties et le type
+ d'informations que chacune peut contenir.
+
+
+ Les sujets de ce tutoriel sont documentés dans le chapitre
+ Structural Elements
+ du guide MEI. Nous vous invitons à consulter ce chapitre pour de plus amples
+ informations.
+
+
+ Gardez à l'esprit que le code que vous écrirez à l'issue de ce tutoriel ne
+ pourra pas être rendu car il ne contiendra pas d'information musicale.
+
+
+ À la fin de ce dernier, vous pourrez poursuivre avec d'autres tutoriels pour
+ explorer d'autres aspects important de MEI. Ces tutoriels peuvent également
+ servir de références - Vous pourrez y retourner.
+
+
+ Afin de commencer, appuyez sur le bouton "continuer" en bas à droite de ce
+ paragraphe.
+
+
diff --git a/_tutorials-FR/100_structure/step-01/100_structure_step-01-desc.html b/_tutorials-FR/100_structure/step-01/100_structure_step-01-desc.html
new file mode 100644
index 00000000..6deb032f
--- /dev/null
+++ b/_tutorials-FR/100_structure/step-01/100_structure_step-01-desc.html
@@ -0,0 +1,57 @@
+
+
+ Première étape : familiarisez-vous avec quelques bases très simples d'XML et
+ apprenez à connaître l'élément racine de MEI.
+
+
+ MEI utilise
+ XML
+ pour représenter la notation musicale. XML est un système d'encodage
+ hiérarchique dans lequel les éléments sont les objets centraux. Ils sont
+ représentés à l'aide de ce qu'on appelle des "balises". La plupart du temps,
+ ces balises consistent en une balise d'ouverture (c'est-à-dire un nom
+ compris entre des crochets angulaires comme <element>) et
+ sa balise de fermeture correspondante (</element>). S'il
+ n'y a aucun contenu entre ces deux balises (comme du texte ou d'autres
+ éléments), l'élément peut être raccourci en une balise autofermante de la
+ forme <element />. Dans tous les cas, chaque balise
+ ouverte doit être fermée plus tard.
+
+
+ Vous pouvez penser à un document XML comme à un arbre qui se ramifie d'un
+ élément racine (extérieur) vers des éléments enfants (intérieurs) imbriqués.
+ L'élément racine est le parent de tous les autres éléments. Dans les
+ documents MEI, cet élément racine est appelé - pour des raisons évidentes -
+ <mei>, mais il aurait pu avoir n'importe quel nom
+ arbitraire.
+
+
+
+ Entrez un élément racine <mei> dans l'éditeur ci-dessous.
+ N'oubliez pas de fermer la balise d'ouverture par une balise de fermeture
+ correspondante.
+
+
+
+ PS : Nous aborderons quelques principes XML de base supplémentaires dans les
+ prochaines étapes. Pour des informations plus détaillées, envisagez de
+ consulter les nombreuses ressources disponibles sur le web, par exemple la
+ Introduction détaillée à XML
+ de l'Initiative d'encodage de texte (TEI).
+
+
diff --git a/_tutorials-FR/100_structure/step-01/100_structure_step-01-prefill.xml b/_tutorials-FR/100_structure/step-01/100_structure_step-01-prefill.xml
new file mode 100644
index 00000000..bc15bf35
--- /dev/null
+++ b/_tutorials-FR/100_structure/step-01/100_structure_step-01-prefill.xml
@@ -0,0 +1 @@
+
diff --git a/_tutorials-FR/100_structure/step-01/100_structure_step-01.xml b/_tutorials-FR/100_structure/step-01/100_structure_step-01.xml
new file mode 100644
index 00000000..948edfd4
--- /dev/null
+++ b/_tutorials-FR/100_structure/step-01/100_structure_step-01.xml
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/_tutorials-FR/100_structure/step-02/100_structure_step-02-desc.html b/_tutorials-FR/100_structure/step-02/100_structure_step-02-desc.html
new file mode 100644
index 00000000..95fa528f
--- /dev/null
+++ b/_tutorials-FR/100_structure/step-02/100_structure_step-02-desc.html
@@ -0,0 +1,52 @@
+
+
+ Deuxième étape : Apprendre le fonctionnement et l'utilisation des espaces de
+ noms.
+
+
+ Comme nous l'avions mentionés dans l'étape précédente, le nom de l'élément
+ racine d'un document XML est un nom arbitraire qui ne possède aucune
+ signification lors de son traitement par la machine. Afin de clarifier le
+ contexte d'un élément et d'éviter les conflits, le XML uttilise ce qu'on
+ appelle les
+ espaces de noms. Ces espaces de noms peuvent être déclarés en ajoutant
+ @xmlns dans l'élément racine.
+
+
+ Par exemple, l'espace de nom MEI est
+ http://www.music-encoding.org/ns/mei et peut être déclaré ainsi
+ :
+ xmlns="http://www.music-encoding.org/ns/mei"
+
+
+ Les éléments précédés du signe @ comme le précédant exemple
+ @xmlns se réfèrent à des attribut XML. (Ces références sont une
+ pratique courante provenant de le langage de requête
+ XPath.) Les attributs contiennent des informations specifique (des valeurs
+ attributs) qui s'attachent aux éléments. Contrairement aux éléments, les
+ attributs XML n'ont pas de balise ouvrante ou fermante. Ils se placent à
+ l'intérieur de la balise ouvrante d'un élément, à côté de son nom. Ils se
+ composent du nom de l'attribut, du signe = et de la valeur de
+ l'attribut, qui doit toujours être mise entre guillemets (simple ou
+ doubles). Plusieurs attributs sont séparés par des espaces. Notez que le
+ signe @ avant le nom d'un attribut n'apparaît pas dans le code
+ MEI. Il s'agit uniquement d'une convention d'écriture afin de bien
+ distinguer les attributs quand on s'y réfère dans un contexte autre que le
+ code MEI, comme dans un tutoriel par exemple !
+
+
+
+ Dans l'éditeur ci-dessous, ajoutez une déclaration d'espace de nom MEI
+ MEI root element.
+
+
diff --git a/_tutorials-FR/100_structure/step-02/100_structure_step-02-prefill.xml b/_tutorials-FR/100_structure/step-02/100_structure_step-02-prefill.xml
new file mode 100644
index 00000000..3958eccf
--- /dev/null
+++ b/_tutorials-FR/100_structure/step-02/100_structure_step-02-prefill.xml
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/_tutorials-FR/100_structure/step-02/100_structure_step-02.xml b/_tutorials-FR/100_structure/step-02/100_structure_step-02.xml
new file mode 100644
index 00000000..0936760f
--- /dev/null
+++ b/_tutorials-FR/100_structure/step-02/100_structure_step-02.xml
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/_tutorials-FR/100_structure/step-03/100_structure_step-03-desc.html b/_tutorials-FR/100_structure/step-03/100_structure_step-03-desc.html
new file mode 100644
index 00000000..ec1165eb
--- /dev/null
+++ b/_tutorials-FR/100_structure/step-03/100_structure_step-03-desc.html
@@ -0,0 +1,29 @@
+
+
+ Troisième étape : Découvrir les élements enfant de l'élément racine <mei> : <meiHead>
+ and <music>.
+
+
+ Bon travail! Maintenant que nous avons déclaré un espace de noms dans notre élément racine, tous les autres éléments
+ imbriqués dedans peuvent être résolus conformément à l'espace de noms MEI par un traitement automatique.
+
+ Comme nous l'avions vu, vous pouvez imaginer un document XML comme un arbre qui se ramifie à partir d'un élément racine
+ vers des éléments enfants imbriqués. Un fichier encodé en MEI contient au moins deux structures à l'intérieur de
+ de l'élément racine <mei> :
+
+
+
+ <meiHead> - contient un ensemble d'éléments qui fournissent des métadonnées liées au fichier encodé en MEI,
+ comme des informations bibliographiques, des déclarations de responsabilité, des normes d'encodage ou une provenance.
+
+
+ <music> - contient un ensemble d'éléments permettant l'encodage du contenu musical réel.
+ Entre autres, il peut comprendre des éléments structurels pour décrire la forme d'une pièce musicale (sections,
+ mouvements, groupes de documents), ou des éléments de notation, tels que des notes, des silences, des articulations ou des dynamiques.
+
+
+
+
Dans l'éditeur ci-dessous, ajoutez un élément <meiHead> et un élément <music> à l'intérieur
+ l'élément racine <mei>.
+
+ Dernière étape : fournir les informations minimales nécessaires pour l'en-tête MEI.
+
+
+ Parfait ! Vous êtes maintenant très proche de disposer d'une structure de fichier MEI de base valide. Ce qui manque encore,
+ ce sont deux éléments incontournable de l'en-tête MEI :
+
+
+ <titleStmt> - un élément conteneur pour le titre et les métadonnées de responsabilité.
+ Le titre d'une entité bibliographique est donné via son sous-élément obligatoire <title>;
+
+
+ <pubStmt> - un élément conteneur pour les informations concernant la publication ou
+ la distribution d'un élément bibliographique, y compris le nom et l'adresse de l'éditeur, la date de
+ publication et d'autres détails pertinents.
+
+
+
+ Ces deux éléments font partie de la description du fichier (<fileDesc>), qui est un élément
+ enfant direct de <meiHead> et permet une description bibliographique complète d'un fichier MEI.
+
+
Dans l'éditeur ci-dessous, ajoutez un élément <fileDesc> à l'intérieur de
+ <meiHead> donné. Ensuite, ajoutez les éléments obligatoires <titleStmt>
+ et <pubStmt> à <fileDesc> et un élément <title> à
+ <titleStmt>.
+
+ Vous venez de terminer votre premier tutoriel sur la MEI, et vous devriez
+ déjà être capable d'encoder une mélodie très simple avec la MEI. Bien sûr,
+ beaucoup plus est nécessaire pour un fichier MEI complet - nous avons omis
+ toutes les informations structurales concernant les mesures et les portées,
+ et vous devez également apprendre à configurer la mesure, la tonalité et les
+ clefs. Comme prochaines étapes avec la MEI, nous aimerions vous recommander
+ nos tutoriels sur les
+ accords
+ ou les
+ silences. Bien sûr, vous pouvez toujours revenir à ceux-ci (ou même à celui-ci)
+ lorsque vous souhaitez vous rappeler comment faire certaines choses en MEI.
+
+
+
+ Dès que vous vous serez bien familiarisé avec la MEI, nous vous invitons à
+ partager votre expérience avec la
+ Communauté MEI
+ et, pourquoi pas, à rédiger vous-même un tutoriel sur un aspect de la MEI
+ qui vous intéresse particulièrement. Vous n'avez pas besoin d'être un expert
+ pour cela - il est bon d'avoir des tutoriels à différents niveaux. Très
+ souvent un tutoriel rédigé par d'autres débutants qui viennent de maîtriser
+ une tâche est plus facile à suivre qu'un guide écrit par une personne plus
+ experimenté qui, ayant complètement assimilé certains éléments, ne se
+ souvient pas qu'ils aient pu être difficile à comprendre des éléments. Nous
+ avons un
+ tutoriel sur la rédaction de tutoriels, et nous proposons des modèles à suivre. C'est facile de devenir un membre
+ actif de la Communauté MEI :-)
+
+
diff --git a/_tutorials-FR/101_quickstart/101_quickstart_step-00-desc.html b/_tutorials-FR/101_quickstart/101_quickstart_step-00-desc.html
new file mode 100644
index 00000000..e2c52c58
--- /dev/null
+++ b/_tutorials-FR/101_quickstart/101_quickstart_step-00-desc.html
@@ -0,0 +1,23 @@
+
+
+ Dans ce tutoriel, vous apprendrez comment encoder une mélodie très simple en
+ MEI. Vous découvrirez comment décrire les aspects les plus fondamentaux de
+ la notation musicale sous forme de données structurées, afin que les
+ ordinateurs puissent analyser votre code.
+
+
+ Le code que vous écrirez sera immédiatement rendu, et le rendu réagira à vos
+ modifications. De cette manière, vous obtiendrez une idée de la façon dont
+ les différents paramètres interagissent.
+
+
+ Une fois que vous aurez terminé ce tutoriel, vous pourrez suivre d'autres
+ tutoriels qui vous introduiront à d'autres aspects importants de MEI. Ces
+ tutoriels servent également de référence simple pour MEI - vous pouvez
+ toujours y revenir.
+
+
+ Pour commencer, veuillez cliquer sur le bouton "continuer" en bas à droite
+ de ce paragraphe.
+
+
diff --git a/_tutorials-FR/101_quickstart/step-01/101_quickstart_step-01-desc.html b/_tutorials-FR/101_quickstart/step-01/101_quickstart_step-01-desc.html
new file mode 100644
index 00000000..515ad472
--- /dev/null
+++ b/_tutorials-FR/101_quickstart/step-01/101_quickstart_step-01-desc.html
@@ -0,0 +1,23 @@
+
+
+ Pour encoder une note, toutes les informations pertinentes doivent être enregistrées sous une forme lisible par
+ la machine. En fonction des besoins d'un projet, la sélection de ce qui est pertinent ou non peut varier, mais
+ dansl e cadre de cette introduction, nous allons traiter des informations les plus basiques d'une note : sa hauteur et sa durée.
+ Pour exprimer la hauteur, MEI utilise la
+ notation de hauteurs américaine, où le "do de serrure" est noté "C4". Cependant, MEI sépare "C4" en deux éléments
+ distincts : le nom de la hauteur (appelé @pname en MEI) et l'octave (@oct). Cette séparation
+ a diverses raisons, qui n'ont pas d'importance ici. Il est également important de noter que les noms de hauteur sont
+ donnés en lettres minuscules en MEI.
+
+
+ L'autre information importante est la durée (@dur). Ici, des valeurs entières simples sont utilisées
+ pour indiquer la durée d'une note. Une note entière reçoit une valeur de 1, une demi-note nécessite 2,
+ une noire 4, et ainsi de suite.
+
+ Nous vous invitons à entrer le code suivant dans la boîte de l'éditeur : <note pname="e" oct="4" dur="4"/>. Vous devriez alors voir apparaître la note rendue. Vous pouvez faire varier les valeurs des attributs pour voir leur influence sur le rendu.
+ Vous verrez également des indications sur la manière d'écrire correctement le code. Quand vous êtes prêt, assurez-vous d'avoir le code correct dans l'éditeur, puis cliquez sur le bouton sur "continuer" en bas à droite.
+
+
+ PS : Si vous n'êtes pas très familier avec XML : Chaque fois que nous faisons référence à des attributs, nous préfixons leur nom avec le signe @. C'est une pratique courante qui provient du langage XPath. Lorsque vous les écrivez en XML, vous ne devez pas inclure le signe @, mais écrire uniquement le nom de l'attribut. N'hésitez pas à consulter notre tutoriel sur les bases de XML.
+
+
diff --git a/_tutorials-FR/101_quickstart/step-01/101_quickstart_step-01-prefill.xml b/_tutorials-FR/101_quickstart/step-01/101_quickstart_step-01-prefill.xml
new file mode 100644
index 00000000..3ac128b2
--- /dev/null
+++ b/_tutorials-FR/101_quickstart/step-01/101_quickstart_step-01-prefill.xml
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/_tutorials-FR/101_quickstart/step-01/101_quickstart_step-01.xml b/_tutorials-FR/101_quickstart/step-01/101_quickstart_step-01.xml
new file mode 100644
index 00000000..ea550c35
--- /dev/null
+++ b/_tutorials-FR/101_quickstart/step-01/101_quickstart_step-01.xml
@@ -0,0 +1,32 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/101_quickstart/step-02/101_quickstart_step-02-desc.html b/_tutorials-FR/101_quickstart/step-02/101_quickstart_step-02-desc.html
new file mode 100644
index 00000000..f4b680b9
--- /dev/null
+++ b/_tutorials-FR/101_quickstart/step-02/101_quickstart_step-02-desc.html
@@ -0,0 +1,10 @@
+
+
+ Félicitations, vous venez d'encoder votre première note en MEI. Maintenant, poursuivons et ajoutons quelques notes supplémentaire pour créer votre première séquence de notes :
+
+
+
+ Essayez de reproduire la séquence ci-dessus en MEI (Vous pouvez copier-coller les éléments de la première note que vous avez encodés au besoin).
+ Chaque note a besoin des attributs @pname, @oct et @dur Gardez à l'esprit que MEI inscrit le nom des notes en minuscule( de a à g).
+
Félicitations, vous venez d'encoder votre première séquence de notes en MEI. Maintenant, nous allons ajuster la valeur de
+ leur durée pour encoder votre première mélodie: "Mary had a little lamb"
+
+
+ Essayez de reproduire la mélodie ci-dessus en MEI. Chaque note a besoin des attributs @pname, @oct et
+ @dur.
+
+
+ Gardez à l'esprit que l'attribut peut prendre comme valeur "1", "2", "4",
+ "8" or "16" pour indiquer les differentes valeurs rhythmique.
+ POur la première note, vous avez besoin d'un attribut supplémentaire :
+ @dots qui permet d'indiquer le nombre de points attaché à la note. Ici il faut indiquer simplement
+ dots="1".
+
+
diff --git a/_tutorials-FR/101_quickstart/step-03/101_quickstart_step-03-prefill.xml b/_tutorials-FR/101_quickstart/step-03/101_quickstart_step-03-prefill.xml
new file mode 100644
index 00000000..441e8481
--- /dev/null
+++ b/_tutorials-FR/101_quickstart/step-03/101_quickstart_step-03-prefill.xml
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/101_quickstart/step-03/101_quickstart_step-03.xml b/_tutorials-FR/101_quickstart/step-03/101_quickstart_step-03.xml
new file mode 100644
index 00000000..50503dfd
--- /dev/null
+++ b/_tutorials-FR/101_quickstart/step-03/101_quickstart_step-03.xml
@@ -0,0 +1,40 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/102_incipit/102_incipit.json b/_tutorials-FR/102_incipit/102_incipit.json
new file mode 100644
index 00000000..32dfd923
--- /dev/null
+++ b/_tutorials-FR/102_incipit/102_incipit.json
@@ -0,0 +1,524 @@
+{
+ "steps": [
+ {
+ "label": "Définition de la partition et des portées",
+ "editorLines": 7,
+ "descFile": "102_incipit_step-01-desc.html",
+ "prefillFile": "102_incipit_step-01-prefill.xml",
+ "xmlFile": "102_incipit_step-01.xml",
+ "xpaths": [
+ {"rule": "count(//mei:scoreDef) = 1", "renderanyway": false, "hint": "You need one scoreDef element."},
+ {"rule": "count(//mei:scoreDef/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the scoreDef element."},
+ {"rule": "count(//mei:staffGrp) = 1", "renderanyway": false, "hint": "You need one staffGrp element."},
+ {"rule": "count(//mei:staffGrp/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the staffGrp element."},
+ {"rule": "//mei:scoreDef/mei:staffGrp", "renderanyway": false, "hint": "staffGrp element has to be a child of scoreDef element."},
+ {"rule": "count(//mei:staffDef) = 1", "renderanyway": false, "hint": "You need one staffDef element."},
+ {"rule": "count(//mei:staffDef/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the staffDef element."},
+ {"rule": "//mei:staffGrp/mei:staffDef", "renderanyway": false, "hint": "staffDef element has to be a child of staffGrp element."}
+ ]
+ },
+ {
+ "label": "Attributs de la partition et des portées",
+ "editorLines": 7,
+ "descFile": "102_incipit_step-02-desc.html",
+ "prefillFile": "102_incipit_step-02-prefill.xml",
+ "xmlFile": "102_incipit_step-02.xml",
+ "xpaths": [
+ {"rule": "count(//mei:scoreDef) = 1", "renderanyway": false, "hint": "You need one scoreDef element."},
+ {"rule": "count(//mei:staffGrp) = 1", "renderanyway": false, "hint": "You need one staffGroup element."},
+ {"rule": "count(//mei:staffGrp/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the staffGrp element."},
+ {"rule": "//mei:scoreDef/mei:staffGrp", "renderanyway": false, "hint": "staffGrp element has to be a child of scoreDef element."},
+ {"rule": "count(//mei:staffDef) = 1", "renderanyway": false, "hint": "You need one staffDef element."},
+ {"rule": "//mei:staffGrp/mei:staffDef", "renderanyway": false, "hint": "staffDef element has to be a child of staffGrp element."},
+ {"rule": "count(//mei:scoreDef/@*) = 2", "renderanyway": false, "hint": "You need two attributes on scoreDef (@key.sig & @meter.sym)."},
+ {"rule": "//mei:scoreDef/@key.sig = '3f'", "renderanyway": false, "hint": "You need a @key.sig attribute with a value of 3f."},
+ {"rule": "//mei:scoreDef/@meter.sym = 'cut'", "renderanyway": false, "hint": "You need an @meter.sym attribute with a value of cut."},
+ {"rule": "count(//mei:staffDef/@*) = 4", "renderanyway": false, "hint": "You need four attributes on staffDef (@n, @lines, @clef.shape & @clef.line)."},
+ {"rule": "//mei:staffDef/@n = '1'", "renderanyway": false, "hint": "You need a @n attribute with a value of 1."},
+ {"rule": "//mei:staffDef/@lines = '5'", "renderanyway": false, "hint": "You need a @lines attribute with a value of 5."},
+ {"rule": "//mei:staffDef/@clef.shape = 'G'", "renderanyway": false, "hint": "You need a @clef.shape attribute with a value of G."},
+ {"rule": "//mei:staffDef/@clef.line = '2'", "renderanyway": false, "hint": "You need a @clef.line attribute with a value of 2."}
+ ]
+ },
+ {
+ "label": "Mesure, portée et couche",
+ "editorLines": 14,
+ "descFile": "102_incipit_step-03-desc.html",
+ "prefillFile": "102_incipit_step-03-prefill.xml",
+ "xmlFile": "102_incipit_step-03.xml",
+ "xpaths": [
+ {"rule": "count(//mei:section) = 1", "renderanyway": false, "hint": "You need one section element."},
+ {"rule": "count(//mei:section/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the section element."},
+ {"rule": "//mei:score/mei:section", "renderanyway": false, "hint": "section element has to be a child of score element."},
+ {"rule": "count(//mei:measure) = 1", "renderanyway": false, "hint": "You need one measure element."},
+ {"rule": "//mei:section/mei:measure", "renderanyway": false, "hint": "measure element has to be a child of section element."},
+ {"rule": "count(//mei:measure/@*) = 1", "renderanyway": false, "hint": "You need one attribute on measure (@n)."},
+ {"rule": "//mei:measure/@n = '0'", "renderanyway": false, "hint": "You need a @n attribute with a value of 0."},
+ {"rule": "count(//mei:staff) = 1", "renderanyway": false, "hint": "You need one staff element."},
+ {"rule": "//mei:measure/mei:staff", "renderanyway": false, "hint": "staff element has to be a child of measure element."},
+ {"rule":"count(//mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on staff (@n)."},
+ {"rule": "//mei:staff/@n = '1'", "renderanyway": false, "hint": "You need a @n attribute with a value of 1."},
+ {"rule": "count(//mei:layer) = 1", "renderanyway": false, "hint": "You need one layer element."},
+ {"rule": "count(//mei:layer/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the layer element."},
+ {"rule": "//mei:staff/mei:layer", "renderanyway": false, "hint": "layer element has to be a child of staff element."}
+ ]
+ },
+ {
+ "label": "La première note",
+ "editorLines": 15,
+ "descFile": "102_incipit_step-04-desc.html",
+ "prefillFile": "102_incipit_step-04-prefill.xml",
+ "xmlFile": "102_incipit_step-04.xml",
+ "xpaths": [
+ {"rule": "count(//mei:note) = 1", "renderanyway": false, "hint": "You need one note element."},
+ {"rule": "count(//mei:note/@*) = 3", "renderanyway": false, "hint": "You need three attributes on note (@pname, @oct a& @dur)."},
+ {"rule": "//mei:note/@pname = 'b'", "renderanyway": false, "hint": "You need a @pname attribute with a value of b."},
+ {"rule": "//mei:note/@oct = '3'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 3."},
+ {"rule": "//mei:note/@dur = '4'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 4."}
+ ]
+ },
+ {
+ "label": "La seconde note",
+ "editorLines": 18,
+ "descFile": "102_incipit_step-05-desc.html",
+ "prefillFile": "102_incipit_step-05-prefill.xml",
+ "xmlFile": "102_incipit_step-05.xml",
+ "xpaths": [
+ {"rule": "count(//mei:section) = 1", "renderanyway": false, "hint": "You need one section element."},
+ {"rule": "count(//mei:section/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the section element."},
+ {"rule": "count(//mei:measure) = 2", "renderanyway": false, "hint": "You need a total of two measure elements."},
+ {"rule": "//mei:section/mei:measure", "renderanyway": false, "hint": "measure element has to be a child of section element."},
+ {"rule": "count(//mei:section/mei:measure) = 2", "renderanyway": false, "hint": "You need two measure children in section element."},
+ {"rule": "count(//mei:measure[1]/@*) = 1 and //mei:measure[1]/@n = 0", "renderanyway": false, "hint": "You need one @n attribute with a value of 0 on the first measure element (@n=0)."},
+ {"rule": "count(//mei:measure[2]/@*) = 1 and //mei:measure[2]/@n = 1", "renderanyway": false, "hint": "You need one @n attribute with a value of 1 on the second measure element (@n=1)."},
+ {"rule": "//mei:measure[1]/mei:staff", "renderanyway": false, "hint": "You need a staff in the first measure element."},
+ {"rule": "//mei:measure[2]/mei:staff", "renderanyway": false, "hint": "You need a staff in the second measure element."},
+ {"rule": "count(//mei:measure/mei:staff) = 2", "renderanyway": false, "hint": "You need a staff child in every measure element."},
+ {"rule": "count(//mei:measure[1]/mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on the staff of the first measure element (@n)."},
+ {"rule": "count(//mei:measure[2]/mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on the staff of the second measure element (@n)."},
+ {"rule": "//mei:measure[1]/mei:staff/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on the first staff element."},
+ {"rule": "//mei:measure[2]/mei:staff/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on the second staff element."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer", "renderanyway": false, "hint": "You need a layer element in the first staff element."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer", "renderanyway": false, "hint": "You need a layer element in the second staff element."},
+ {"rule": "count(//mei:staff/mei:layer) = 2", "renderanyway": false, "hint": "You need a layer child in every staff element."},
+ {"rule": "count(//mei:layer/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the layer elements."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer/mei:note", "renderanyway": false, "hint": "You need a note in the first layer element."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note", "renderanyway": false, "hint": "You need a note in the second layer element."},
+ {"rule": "count(//mei:layer/mei:note) = 2", "renderanyway": false, "hint": "You need a note child in every layer element."},
+ {"rule": "count(//mei:measure[1]/mei:staff/mei:layer/mei:note/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the first note (@pname, @oct & @dur)."},
+ {"rule": "count(//mei:measure[2]/mei:staff/mei:layer/mei:note/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the second note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer/mei:note/@pname = 'b'", "renderanyway": false, "hint": "You need a @pname attribute with a value of b on first note."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer/mei:note/@oct = '3'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 3 on first note."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer/mei:note/@dur = '4'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 4 on first note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note/@pname = 'e'", "renderanyway": false, "hint": "You need a @pname attribute with a value of e on second note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on second note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note/@dur = '4'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 4 on second note."}
+ ]
+ },
+ {
+ "label": "Ligatures",
+ "editorLines": 12,
+ "descFile": "102_incipit_step-06-desc.html",
+ "prefillFile": "102_incipit_step-06-prefill.xml",
+ "xmlFile": "102_incipit_step-06.xml",
+ "xpaths": [
+ {"rule": "count(//mei:measure) = 2", "renderanyway": false, "hint": "You need a measure element."},
+ {"rule": "count(//mei:measure[2]/@*) = 1", "renderanyway": false, "hint": "You need one attribute on measure (@n)."},
+ {"rule": "//mei:measure[2]/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on measure."},
+ {"rule": "//mei:measure[2]/mei:staff", "renderanyway": false, "hint": "You need a staff in the measure element."},
+ {"rule": "count(//mei:measure[2]/mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on staff (@n)."},
+ {"rule": "//mei:measure[2]/mei:staff/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on staff."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer", "renderanyway": false, "hint": "You need a layer element in the staff element."},
+ {"rule": "count(//mei:layer/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the layer element."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[1]", "renderanyway": false, "hint": "First note element has to be a child of the layer element."},
+ {"rule": "count(//mei:measure[2]/mei:staff/mei:layer/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the first note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[1]/@pname = 'e'", "renderanyway": false, "hint": "You need a @pname attribute with a value of e on first note element."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[1]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on first note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[1]/@dur = '4'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 4 on first note."},
+ {"rule": "count(//mei:beam) = '1'", "renderanyway": false, "hint": "You need one beam element."},
+ {"rule": "//mei:layer/mei:beam", "renderanyway": false, "hint": "beam element has to be a child of the layer element."},
+ {"rule": "//mei:layer/mei:note/following-sibling::mei:beam", "renderanyway": false, "hint": "beam element has to follow the first (e flat) note element."},
+ {"rule": "count(//mei:layer/mei:note/following-sibling::*) = 1", "renderanyway": false, "hint": "You need only one element to follow the first (e flat) note element."},
+ {"rule": "count(//mei:beam/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the beam element."},
+ {"rule": "count(//mei:beam/mei:note) = 2", "renderanyway": false, "hint": "You need two note elements inside the beam element."},
+ {"rule": "count(//mei:beam/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the first beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:beam/mei:note[1]/@pname = 'e'", "renderanyway": false, "hint": "You need a @pname attribute with a value of e on the first beamed note."},
+ {"rule": "//mei:beam/mei:note[1]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the first beamed note."},
+ {"rule": "//mei:beam/mei:note[1]/@dur = '8'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 8 on the first beamed note."},
+ {"rule": "count(//mei:beam/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the second beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:beam/mei:note[2]/@pname = 'g'", "renderanyway": false, "hint": "You need a @pname attribute with a value of g on the second beamed note."},
+ {"rule": "//mei:beam/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the second beamed note."},
+ {"rule": "//mei:beam/mei:note[2]/@dur = '8'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 8 on the second beamed note."}
+ ]
+ },
+ {
+ "label": "Rythme pointé",
+ "editorLines": 14,
+ "descFile": "102_incipit_step-07-desc.html",
+ "prefillFile": "102_incipit_step-07-prefill.xml",
+ "xmlFile": "102_incipit_step-07.xml",
+ "xpaths": [
+ {"rule": "count(//mei:measure) = 2", "renderanyway": false, "hint": "You need a measure element."},
+ {"rule": "count(//mei:measure[2]/@*) = 1", "renderanyway": false, "hint": "You need one attribute on the measure (@n)."},
+ {"rule": "//mei:measure[2]/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on measure."},
+ {"rule": "//mei:measure[2]/mei:staff", "renderanyway": false, "hint": "You need a staff in the measure element."},
+ {"rule": "count(//mei:measure[2]/mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on staff (@n)."},
+ {"rule": "//mei:measure[2]/mei:staff/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on staff."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer", "renderanyway": false, "hint": "You need a layer element in the staff element."},
+ {"rule": "count(//mei:layer/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the layer element."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[1]", "renderanyway": false, "hint": "First note element has to be a child of layer element."},
+ {"rule": "count(//mei:measure[2]/mei:staff/mei:layer/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the first note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[1]/@pname = 'e'", "renderanyway": false, "hint": "You need a @pname attribute with a value of e on first note element."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[1]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on first note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[1]/@dur = '4'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 4 on first note."},
+ {"rule": "count(//mei:beam) = '1'", "renderanyway": false, "hint": "You need one beam element."},
+ {"rule": "//mei:layer/mei:beam", "renderanyway": false, "hint": "beam element has to be a child of the layer element."},
+ {"rule": "//mei:layer/mei:note/following-sibling::mei:beam", "renderanyway": false, "hint": "beam element has to follow the first (e flat) note element."},
+ {"rule": "count(//mei:beam/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the beam element."},
+ {"rule": "count(//mei:beam/mei:note) = 2", "renderanyway": false, "hint": "You need two note elements inside the beam element."},
+ {"rule": "count(//mei:beam/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the first beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:beam/mei:note[1]/@pname = 'e'", "renderanyway": false, "hint": "You need a @pname attribute with a value of e on the first beamed note."},
+ {"rule": "//mei:beam/mei:note[1]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the first beamed note."},
+ {"rule": "//mei:beam/mei:note[1]/@dur = '8'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 8 on the first beamed note."},
+ {"rule": "count(//mei:beam/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the second beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:beam/mei:note[2]/@pname = 'g'", "renderanyway": false, "hint": "You need a @pname attribute with a value of g on second beamed note."},
+ {"rule": "//mei:beam/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on second beamed note."},
+ {"rule": "//mei:beam/mei:note[2]/@dur = '8'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 8 on second beamed note."},
+ {"rule": "//mei:layer/mei:beam/following-sibling::mei:note", "renderanyway": false, "hint": "One note element has to follow the beam element."},
+ {"rule": "//mei:layer/mei:beam/following-sibling::mei:note/following-sibling::mei:note", "renderanyway": false, "hint": "Another note element has to follow the note after the beam element."},
+ {"rule": "count(//mei:measure[2]/mei:staff/mei:layer/mei:note) = 3", "renderanyway": false, "hint": "You need a total of three note elements as direct childs of this measure's layer."},
+ {"rule": "count(//mei:layer/mei:note/following-sibling::*) = 3", "renderanyway": false, "hint": "You need three elements to follow the first note element."},
+ {"rule": "count(//mei:measure[2]/mei:staff/mei:layer/mei:note[2]/@*) = 4", "renderanyway": false, "hint": "You need four attributes on the dotted quarter note (@pname, @oct, @dur & @dots)."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[2]/@pname = 'f'", "renderanyway": false, "hint": "You need a @pname attribute with a value of f on the dotted quarter note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the dotted quarter note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[2]/@dur = '4'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 4 on the dotted quarter note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[2]/@dots = '1'", "renderanyway": false, "hint": "You need a @dots attribute with a value of 1 on the dotted quarter note."},
+ {"rule": "count(//mei:measure[2]/mei:staff/mei:layer/mei:note[3]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the eighth note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[3]/@pname = 'd'", "renderanyway": false, "hint": "You need a @pname attribute with a value of d on the eighth note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[3]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the eighth note."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[3]/@dur = '8'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 8 on the eighth note."}
+ ]
+ },
+ {
+ "label": "La mesure pleine",
+ "editorLines": 14,
+ "descFile": "102_incipit_step-08-desc.html",
+ "prefillFile": "102_incipit_step-08-prefill.xml",
+ "xmlFile": "102_incipit_step-08.xml",
+ "xpaths": [
+ {"rule": "count(//mei:measure) = 3", "renderanyway": false, "hint": "You need one measure element."},
+ {"rule": "count(//mei:measure[3]/@*) = 1", "renderanyway": false, "hint": "You need one attribute on measure (@n)."},
+ {"rule": "//mei:measure[3]/@n = 2", "renderanyway": false, "hint": "You need a @n attribute with a value of 2 on measure."},
+ {"rule": "//mei:measure[3]/mei:staff", "renderanyway": false, "hint": "You need a staff element in the measure element."},
+ {"rule": "count(//mei:measure[3]/mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on staff (@n)."},
+ {"rule": "//mei:measure[3]/mei:staff/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on staff."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer", "renderanyway": false, "hint": "You need a layer element in the staff element."},
+ {"rule": "count(//mei:layer/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the layer element."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[1]", "renderanyway": false, "hint": "First note element has to be child of the layer element."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the first note element (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[1]/@pname = 'e'", "renderanyway": false, "hint": "You need a @pname attribute with a value of e on the first note element."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[1]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the first note element."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[1]/@dur = '4'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 4 on the first note element."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:beam) = '1'", "renderanyway": false, "hint": "You need one beam element."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:beam", "renderanyway": false, "hint": "beam element has to be a child of the layer element."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note/following-sibling::mei:beam", "renderanyway": false, "hint": "beam element has to follow the first note element."},
+ {"rule": "count(//mei:beam/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the beam element."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:beam/mei:note) = 2", "renderanyway": false, "hint": "You need two note elements inside the beam element."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:beam/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the first beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:beam/mei:note[1]/@pname = 'e'", "renderanyway": false, "hint": "You need a @pname attribute with a value of e on the first beamed note."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:beam/mei:note[1]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the first beamed note."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:beam/mei:note[1]/@dur = '8'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 8 on the first beamed note."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:beam/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the second beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:beam/mei:note[2]/@pname = 'g'", "renderanyway": false, "hint": "You need a @pname attribute with a value of g on the second beamed note."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:beam/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the second beamed note."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:beam/mei:note[2]/@dur = '8'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 8 on the second beamed note."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:beam/following-sibling::mei:note", "renderanyway": false, "hint": "One note element has to follow the beam element."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:beam/following-sibling::mei:note/following-sibling::mei:note", "renderanyway": false, "hint": "Another note element has to follow the note after the beam element."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:note) = 3", "renderanyway": false, "hint": "You need a total of three note elements as childs of this measure's layer."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:note/following-sibling::*) = 3", "renderanyway": false, "hint": "You need three elements to follow the first note element."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:note[2]/@*) = 4", "renderanyway": false, "hint": "You need four attributes on the dotted quarter note (@pname, @oct, @dur & @dots)."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[2]/@pname = 'b'", "renderanyway": false, "hint": "You need a @pname attribute with a value of b on the dotted quarter note."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the dotted quarter note."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[2]/@dur = '4'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 4 on the dotted quarter note."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[2]/@dots = '1'", "renderanyway": false, "hint": "You need a @dots attribute with a value of 1 on the dotted quarter note."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:note[3]/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the eighth note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[3]/@pname = 'g'", "renderanyway": false, "hint": "You need a @pname attribute with a value of g on the eighth note ."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[3]/@oct = '4'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 4 on the eighth note ."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[3]/@dur = '8'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 8 on the eighth note ."}
+ ]
+ },
+ {
+ "label": "Les deux dernières mesures",
+ "editorLines": 14,
+ "descFile": "102_incipit_step-09-desc.html",
+ "prefillFile": "102_incipit_step-09-prefill.xml",
+ "xmlFile": "102_incipit_step-09.xml",
+ "xpaths": [
+ {"rule": "count(//mei:measure) = 5", "renderanyway": false, "hint": "You need two measure elements."},
+ {"rule": "//mei:measure[4]/following-sibling::mei:measure", "renderanyway": false, "hint": "Measures have to follow each other."},
+ {"rule": "count(//mei:measure[4]/@*) = 1", "renderanyway": false, "hint": "You need one attribute on the first measure element (@n)."},
+ {"rule": "//mei:measure[4]/@n = 3", "renderanyway": false, "hint": "You need a @n attribute with a value of 3 on the first measure element."},
+ {"rule": "count(//mei:measure[5]/@*) = 1", "renderanyway": false, "hint": "You need one attribute on the second measure element (@n)."},
+ {"rule": "//mei:measure[5]/@n = 4", "renderanyway": false, "hint": "You need a @n attribute with a value of 4 on the second measure element."},
+ {"rule": "//mei:measure[4]/mei:staff", "renderanyway": false, "hint": "Measure n=3: You need a staff element inside the measure element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/@*) = 1", "renderanyway": false, "hint": "Measure n=3: You need one attribute on staff (@n)."},
+ {"rule": "//mei:measure[4]/mei:staff/@n = 1", "renderanyway": false, "hint": "Measure n=3: You need a @n attribute with a value of 1 on staff."},
+ {"rule": "//mei:measure[5]/mei:staff", "renderanyway": false, "hint": "Measure n=4: You need a staff element inside the measure element."},
+ {"rule": "count(//mei:measure[5]/mei:staff/@*) = 1", "renderanyway": false, "hint": "Measure n=4: You need one attribute on staff (@n)."},
+ {"rule": "//mei:measure[5]/mei:staff/@n = 1", "renderanyway": false, "hint": "Measure n=4: You need a @n attribute with a value of 1 on staff."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer", "renderanyway": false, "hint": "Measure n=3: You need a layer element inside staff."},
+ {"rule": "count(//mei:layer/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the layer elements."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer", "renderanyway": false, "hint": "Measure n=4: You need a layer element inside staff."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam) = '2'", "renderanyway": false, "hint": "Measure n=3: You need two beam elements as direct children of layer."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note) = '1'", "renderanyway": false, "hint": "Measure n=3: You need one note element as direct child of layer."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/following-sibling::mei:note/following-sibling::mei:beam", "renderanyway": false, "hint": "Measure n=3: Note element has to be placed between the two beam elements."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/*) = '3'", "renderanyway": false, "hint": "Measure n=3: You need a total of 3 elements as children of layer."},
+ {"rule": "count(//mei:beam/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the beam elements."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the note element (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/@pname = 'e'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of e on note element."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on note element."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/@dur = '4'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 4 on note element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note) = 4", "renderanyway": false, "hint": "Measure n=3: You need four note elements inside the first beam element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the first beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@pname = 'a'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of a on the first beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@oct = '4'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 4 on the first beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the first beamed note."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the second beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@pname = 'b'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of b on the second beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 4 on the second beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the second beamed note."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the third beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@pname = 'c'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of c on the third beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the third beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the third beamed note."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the fourth beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@pname = 'd'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of d on the fourth beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the fourth beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the fourth beamed note."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note) = 2", "renderanyway": false, "hint": "Measure n=3: You need two note elements inside the second beam element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the first beamed note (@pname, @oct & @dur) of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@pname = 'd'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of d on the first beamed note of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the first beamed note of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the first beamed note of the second beam."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the second beamed note (@pname, @oct & @dur) of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@pname = 'b'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of b on the second beamed note of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 4 on the second beamed note of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the second beamed note of the second beam."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:note) = '2'", "renderanyway": false, "hint": "Measure n=4: You need two note elements as children of layer."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:rest) = '1'", "renderanyway": false, "hint": "Measure n=4: You need one rest element as child of layer."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/following-sibling::mei:note/following-sibling::mei:rest", "renderanyway": false, "hint": "Measure n=4: Rest element has to follow the two note elements."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/*) = '3'", "renderanyway": false, "hint": "Measure n=4: You need a total of 3 elements as children of layer."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "Measure n=4: You need three attributes on the first note element (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/@pname = 'c'", "renderanyway": false, "hint": "Measure n=4: You need a @pname attribute with a value of c on the first note element."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/@oct = '5'", "renderanyway": false, "hint": "Measure n=4: You need an @oct attribute with a value of 5 on the first note element."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/@dur = '4'", "renderanyway": false, "hint": "Measure n=4: You need a @dur attribute with a value of 4 on the first note element."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "Measure n=4: You need three attributes on the second note element (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[2]/@pname = 'b'", "renderanyway": false, "hint": "Measure n=4: You need a @pname attribute with a value of b on the second note element."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "Measure n=4: You need an @oct attribute with a value of 4 on the second note element."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[2]/@dur = '4'", "renderanyway": false, "hint": "Measure n=4: You need a @dur attribute with a value of 4 on the second note element."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:rest/@*) = 1", "renderanyway": false, "hint": "Measure n=4: You need one attribute on the rest element (@dur)."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:rest/@dur = '4'", "renderanyway": false, "hint": "Measure n=4: You need a @dur attribute with a value of 4 on the rest element."}
+ ]
+ },
+ {
+ "label": "Articulations",
+ "editorLines": 50,
+ "descFile": "102_incipit_step-10-desc.html",
+ "prefillFile": "102_incipit_step-10-prefill.xml",
+ "xmlFile": "102_incipit_step-10.xml",
+ "xpaths": [
+ {"rule": "count(//mei:measure) = 5", "renderanyway": false, "hint": "You need three measure elements."},
+ {"rule": "//mei:measure[4]/following-sibling::mei:measure", "renderanyway": false, "hint": "Measures have to follow each other."},
+ {"rule": "count(//mei:measure[4]/@*) = 1", "renderanyway": false, "hint": "You need one attribute on the first measure element (@n)."},
+ {"rule": "//mei:measure[4]/@n = 3", "renderanyway": false, "hint": "You need a @n attribute with a value of 3 on the first measure element."},
+ {"rule": "count(//mei:measure[5]/@*) = 1", "renderanyway": false, "hint": "You need one attribute on the second measure element (@n)."},
+ {"rule": "//mei:measure[5]/@n = 4", "renderanyway": false, "hint": "You need a @n attribute with a value of 4 on the second measure element."},
+ {"rule": "//mei:measure[4]/mei:staff", "renderanyway": false, "hint": "You need a staff element inside the first measure element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on staff (@n)."},
+ {"rule": "//mei:measure[4]/mei:staff/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on staff."},
+ {"rule": "//mei:measure[5]/mei:staff", "renderanyway": false, "hint": "You need a staff element inside the second measure element."},
+ {"rule": "count(//mei:measure[5]/mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on staff (@n)."},
+ {"rule": "//mei:measure[5]/mei:staff/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on staff."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer", "renderanyway": false, "hint": "Measure n=3: You need a layer element inside staff."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer", "renderanyway": false, "hint": "Measure n=4: You need a layer element inside staff."},
+ {"rule": "count(//mei:layer/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the layer elements."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam) = '2'", "renderanyway": false, "hint": "Measure n=3: You need two beam elements as children of layer."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note) = '1'", "renderanyway": false, "hint": "Measure n=3: You need one note element as child of layer."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/following-sibling::mei:note/following-sibling::mei:beam", "renderanyway": false, "hint": "Measure n=3: Note element has to be placed between the two beam elements."},
+ {"rule": "count(//mei:beam/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the beam elements."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the note element (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/@pname = 'e'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of e on the note element."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the note element."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/@dur = '4'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 4 on the note element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note) = 4", "renderanyway": false, "hint": "Measure n=3: You need four note elements inside the first beam element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the first beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@pname = 'a'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of a on the first beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@oct = '4'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 4 on the first beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the first beamed note."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the second beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@pname = 'b'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of b on the second beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 4 on the second beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the second beamed note."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the third beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@pname = 'c'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of c on the third beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the third beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the third beamed note."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the fourth beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@pname = 'd'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of d on the fourth beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the fourth beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the fourth beamed note."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note) = 2", "renderanyway": false, "hint": "Measure n=3: You need two note elements inside the second beam element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the first beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@pname = 'd'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of d on the first beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the first beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the first beamed note."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the second beamed note (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@pname = 'b'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of b on the second beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 4 on the second beamed note."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the second beamed note."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:note) = '2'", "renderanyway": false, "hint": "Measure n=4: You need two note elements as children of layer."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:rest) = '1'", "renderanyway": false, "hint": "Measure n=4: You need one rest element as child of layer."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/following-sibling::mei:note/following-sibling::mei:rest", "renderanyway": false, "hint": "Measure n=4: Rest element has to follow the two note elements."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "Measure n=4: You need three attributes on the first note element (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/@pname = 'c'", "renderanyway": false, "hint": "Measure n=4: You need a @pname attribute with a value of c on the first note element."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/@oct = '5'", "renderanyway": false, "hint": "Measure n=4: You need an @oct attribute with a value of 5 on the first note element."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[1]/@dur = '4'", "renderanyway": false, "hint": "Measure n=4: You need a @dur attribute with a value of 4 on the first note element."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "Measure n=4: You need three attributes on the second note element (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[2]/@pname = 'b'", "renderanyway": false, "hint": "Measure n=4: You need a @pname attribute with a value of b on the second note element."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "Measure n=4: You need an @oct attribute with a value of 4 on the second note element."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:note[2]/@dur = '4'", "renderanyway": false, "hint": "Measure n=4: You need a @dur attribute with a value of 4 on the second note element."},
+ {"rule": "count(//mei:measure[5]/mei:staff/mei:layer/mei:rest/@*) = 1", "renderanyway": false, "hint": "Measure n=4: You need one attribute on the rest element (@dur)."},
+ {"rule": "//mei:measure[5]/mei:staff/mei:layer/mei:rest/@dur = '4'", "renderanyway": false, "hint": "Measure n=4: You need a @dur attribute with a value of 4 on the rest element."},
+ {"rule": "count(//mei:measure[2]/mei:staff/mei:layer/mei:note[2]/mei:artic) = '1'", "renderanyway": false, "hint": "Measure n=1: You need an artic element as children of the second note element."},
+ {"rule": "count(//mei:measure[2]/mei:staff/mei:layer/mei:note[2]/mei:artic/@*) = 2", "renderanyway": false, "hint": "Measure n=1: You need two attributes on the artic element (@artic, @place)."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[2]/mei:artic/@artic = 'acc'", "renderanyway": false, "hint": "Measure n=1: You need a @artic attribute with a value of acc on artic element."},
+ {"rule": "//mei:measure[2]/mei:staff/mei:layer/mei:note[2]/mei:artic/@place = 'above'", "renderanyway": false, "hint": "Measure n=1: You need an @place attribute with a value of above on the artic element."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:note[2]/mei:artic) = '1'", "renderanyway": false, "hint": "Measure n=2: You need a artic element as children of the second note element."},
+ {"rule": "count(//mei:measure[3]/mei:staff/mei:layer/mei:note[2]/mei:artic/@*) = 2", "renderanyway": false, "hint": "Measure n=2: You need two attributes on the artic element (@artic, @place)."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[2]/mei:artic/@artic = 'acc'", "renderanyway": false, "hint": "Measure n=2: You need a @artic attribute with a value of acc on artic element."},
+ {"rule": "//mei:measure[3]/mei:staff/mei:layer/mei:note[2]/mei:artic/@place = 'above'", "renderanyway": false, "hint": "Measure n=2: You need an @place attribute with a value of above on the artic element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note/mei:artic) = '1'", "renderanyway": false, "hint": "Measure n=3: You need a artic element as children of the note element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note/mei:artic/@*) = 2", "renderanyway": false, "hint": "Measure n=3: You need two attributes on the artic element (@artic, @place)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/mei:artic/@artic = 'acc'", "renderanyway": false, "hint": "Measure n=3: You need a @artic attribute with a value of acc on artic element."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/mei:artic/@place = 'above'", "renderanyway": false, "hint": "Measure n=3: You need an @place attribute with a value of above on the artic element."}
+ ]
+ },
+ {
+ "label": "Dynamiques (en référence aux indications de temps)",
+ "editorLines": 10,
+ "descFile": "102_incipit_step-11-desc.html",
+ "prefillFile": "102_incipit_step-11-prefill.xml",
+ "xmlFile": "102_incipit_step-11.xml",
+ "xpaths": [
+ {"rule": "count(//mei:measure[@n=0]) = 1", "renderanyway": false, "hint": "You need one measure with n = 0."},
+ {"rule": "//mei:measure[1]/mei:staff", "renderanyway": false, "hint": "You need a staff element inside the measure element."},
+ {"rule": "count(//mei:measure[1]/mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on staff (@n)."},
+ {"rule": "//mei:measure[1]/mei:staff/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on staff."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer", "renderanyway": false, "hint": "You need a layer element inside staff."},
+ {"rule": "count(//mei:measure[1]/mei:staff/mei:layer/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the layer element."},
+ {"rule": "count(//mei:measure[1]/mei:staff/mei:layer/mei:note) = 1", "renderanyway": false, "hint": "You need one note element."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer/mei:note", "renderanyway": false, "hint": "The note element has to be a child of the layer element."},
+ {"rule": "count(//mei:measure[1]/mei:staff/mei:layer/mei:note/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the note element (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer/mei:note/@pname = 'b'", "renderanyway": false, "hint": "You need a @pname attribute with a value of b on note."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer/mei:note/@oct = '3'", "renderanyway": false, "hint": "You need an @oct attribute with a value of 3 on note."},
+ {"rule": "//mei:measure[1]/mei:staff/mei:layer/mei:note/@dur = '4'", "renderanyway": false, "hint": "You need a @dur attribute with a value of 4 on note."},
+ {"rule": "count(//mei:measure[1]/mei:dynam) = '1'", "renderanyway": false, "hint": "You need a dynam element as children of measure."},
+ {"rule": "//mei:measure[1]/mei:staff/following-sibling::mei:dynam", "renderanyway": false, "hint": "dynam element as has to follow the staff element."},
+ {"rule": "count(//mei:measure[1]/mei:dynam/@*) = 3", "renderanyway": false, "hint": "You need three attributes on the dynam element (@staff, @tstamp & @place)."},
+ {"rule": "//mei:measure[1]/mei:dynam/@staff = '1'", "renderanyway": false, "hint": "You need a @staff attribute with a value of 1 on the dynam element."},
+ {"rule": "//mei:measure[1]/mei:dynam/@tstamp = '1'", "renderanyway": false, "hint": "You need a @tstamp attribute with a value of 1 on the dynam element."},
+ {"rule": "//mei:measure[1]/mei:dynam/@place = 'below'", "renderanyway": false, "hint": "You need an @place attribute with a value of below on the dynam element."},
+ {"rule": "//mei:measure[1]/mei:dynam/text() = 'ff'", "renderanyway": false, "hint": "You need a text value of ff as content of the dynam element."}
+ ]
+ },
+ {
+ "label": "Ligatures de liaison (en référence aux identifiants XML)",
+ "editorLines": 25,
+ "descFile": "102_incipit_step-12-desc.html",
+ "prefillFile": "102_incipit_step-12-prefill.xml",
+ "xmlFile": "102_incipit_step-12.xml",
+ "xpaths": [
+ {"rule": "count(//mei:measure[@n=3]) = 1", "renderanyway": false, "hint": "You need one measure with n = 3."},
+ {"rule": "//mei:measure[4]/mei:staff", "renderanyway": false, "hint": "You need a staff element inside the measure element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/@*) = 1", "renderanyway": false, "hint": "You need one attribute on staff (@n)."},
+ {"rule": "//mei:measure[4]/mei:staff/@n = 1", "renderanyway": false, "hint": "You need a @n attribute with a value of 1 on staff."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer", "renderanyway": false, "hint": "You need a layer element inside staff."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the layer element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam) = '2'", "renderanyway": false, "hint": "Measure n=3: You need two beam elements as children of layer."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note) = '1'", "renderanyway": false, "hint": "Measure n=3: You need one note element as child of layer."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/following-sibling::mei:note/following-sibling::mei:beam", "renderanyway": false, "hint": "Measure n=3: Note element has to be placed between the two beam elements."},
+ {"rule": "count(//mei:beam/@*) = 0", "renderanyway": false, "hint": "You do not need an attribute on the beam elements."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the note element (@pname, @oct & @dur)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/@pname = 'e'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of e on the note element."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the note element."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/@dur = '4'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 4 on the note element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note) = 4", "renderanyway": false, "hint": "Measure n=3: You need four note elements inside the first beam element."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@pname = 'a'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of a on the first beamed note of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@oct = '4'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 4 on the first beamed note of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the first beamed note of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@pname = 'b'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of b on the second beamed note of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 4 on the second beamed note of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the second beamed note of the first beam."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the third beamed note (@pname, @oct & @dur) of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@pname = 'c'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of c on the third beamed note of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the third beamed note of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[3]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the third beamed note of the first beam."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the fourth beamed note (@pname, @oct & @dur) of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@pname = 'd'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of d on the fourth beamed note of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the fourth beamed note of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[4]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the fourth beamed note of the first beam."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note) = 2", "renderanyway": false, "hint": "Measure n=3: You need two note elements inside the second beam element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the first beamed note (@pname, @oct & @dur) of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@pname = 'd'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of d on the first beamed note of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@oct = '5'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 5 on the first beamed note of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[1]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the first beamed note of the second beam."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@*) = 3", "renderanyway": false, "hint": "Measure n=3: You need three attributes on the second beamed note (@pname, @oct & @dur) of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@pname = 'b'", "renderanyway": false, "hint": "Measure n=3: You need a @pname attribute with a value of b on the second beamed note of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@oct = '4'", "renderanyway": false, "hint": "Measure n=3: You need an @oct attribute with a value of 4 on the second beamed note of the second beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[2]/mei:note[2]/@dur = '8'", "renderanyway": false, "hint": "Measure n=3: You need a @dur attribute with a value of 8 on the second beamed note of the second beam."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note/mei:artic) = '1'", "renderanyway": false, "hint": "Measure n=3: You need a artic element as children of the note element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:note/mei:artic/@*) = 2", "renderanyway": false, "hint": "Measure n=3: You need two attributes on the artic element (@artic, @place)."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/mei:artic/@artic = 'acc'", "renderanyway": false, "hint": "Measure n=3: You need a @artic attribute with a value of acc on artic element."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:note/mei:artic/@place = 'above'", "renderanyway": false, "hint": "Measure n=3: You need an @place attribute with a value of above on the artic element."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@*) = 4", "renderanyway": false, "hint": "You need four attributes on the first beamed note (@pname, @oct, @dur & @xml:id) of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[1]/@*[name()='xml:id'] = 'd1e4614'", "renderanyway": false, "hint": "You need a @xml:id attribute with a value of `d1e4614` on the first beamed note of the first beam."},
+ {"rule": "count(//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@*) = 4", "renderanyway": false, "hint": "You need four attributes on the second beamed note (@pname, @oct, @dur & @xml:id) of the first beam."},
+ {"rule": "//mei:measure[4]/mei:staff/mei:layer/mei:beam[1]/mei:note[2]/@*[name()='xml:id'] = 'd1e4615'", "renderanyway": false, "hint": "You need a @xml:id attribute with a value of `d1e4615` on the second beamed note of the first beam."},
+ {"rule": "count(//mei:measure[4]/mei:slur) = '1'", "renderanyway": false, "hint": "You need a slur element as child of measure."},
+ {"rule": "//mei:measure[4]/mei:staff/following-sibling::mei:slur", "renderanyway": false, "hint": "slur element has to follow the staff element."},
+ {"rule": "count(//mei:measure[4]/mei:slur/@*) = 4", "renderanyway": false, "hint": "You need four attributes on the slur element (@staff, @curvedir, @startid & @endid)."},
+ {"rule": "//mei:measure[4]/mei:slur/@staff = '1'", "renderanyway": false, "hint": "You need a @staff attribute with a value of 1 on slur."},
+ {"rule": "//mei:measure[4]/mei:slur/@curvedir = 'above'", "renderanyway": false, "hint": "You need a @curvedir attribute with a value of above on slur."},
+ {"rule": "//mei:measure[4]/mei:slur/@startid = '#d1e4614'", "renderanyway": false, "hint": "You need a @startid attribute with a value of #d1e4614 on slur."},
+ {"rule": "//mei:measure[4]/mei:slur/@endid = '#d1e4615'", "renderanyway": false, "hint": "You need an @endid attribute with a value of #d1e4615 on slur."}
+ ]
+ }
+ ],
+ "end": "102_incipit_end.html",
+ "resp": [
+ {
+ "name": "Margrethe S. Bue",
+ "affiliation": "National Library of Norway"
+ },
+ {
+ "name": "Sonja Wronkowska",
+ "affiliation": "RISM Poland | National Library of Poland"
+ },
+ {
+ "name": "Debra Nakos",
+ "affiliation": "University of Maryland, College Park"
+ },
+ {
+ "name": "Johannes Kepper",
+ "affiliation": "Beethovens Werkstatt | Universität Paderborn"
+ },
+ {
+ "name": "Andrew Hankinson",
+ "affiliation": "Bodleian Libraries | University of Oxford"
+ },
+ {
+ "name": "Stefan Münnich",
+ "affiliation": "Anton Webern Gesamtausgabe | University of Basel"
+ }
+ ]
+}
diff --git a/_tutorials-FR/102_incipit/102_incipit.md b/_tutorials-FR/102_incipit/102_incipit.md
new file mode 100644
index 00000000..43755de1
--- /dev/null
+++ b/_tutorials-FR/102_incipit/102_incipit.md
@@ -0,0 +1,13 @@
+---
+layout: tutorials-FR
+type: tutorial-FR
+name: "AVANCÉ : Encodez les incipits"
+fullname: "Un tutoriel avancé sur l'encodage des incipits en MEI"
+data: "102_incipit.json"
+---
+Bienvenue! Dans ce tutoriel vous apprendrez à encoder un incipit (La séquence de notes initiale d'une œuvre musicale) en MEI, en partant de l'exemple suivant :
+
+![Hallingdal Bataljons Marsch](./102_incipit.png)
+
+Au fait : il s'agit du début de _Hallingdal Bataljons Marsch_, l'Opus 1 du compositeur norvégien [Johan Halvorsen](https://fr.wikipedia.org/wiki/Johan_Halvorsen) (1864–1935).
+
diff --git a/_tutorials-FR/102_incipit/102_incipit.png b/_tutorials-FR/102_incipit/102_incipit.png
new file mode 100644
index 00000000..acd2087a
Binary files /dev/null and b/_tutorials-FR/102_incipit/102_incipit.png differ
diff --git a/_tutorials-FR/102_incipit/102_incipit_end.html b/_tutorials-FR/102_incipit/102_incipit_end.html
new file mode 100644
index 00000000..96d82e18
--- /dev/null
+++ b/_tutorials-FR/102_incipit/102_incipit_end.html
@@ -0,0 +1,16 @@
+
+
Félicitations !
+
+ Vous avez maintenant terminé avec succès ce tutoriel avancé, et vous devriez être en mesure d'encoder une mélodie à une voix
+ avec plusieurs mesures, différentes valeurs de notes et de silences, des croches, des liaisons et des indications de nuances.
+
+
+ Comme prochaines étapes avec la MEI, nous aimerions vous recommander d'autres tutoriels. Bien sûr, vous pouvez toujours revenir à
+ ceux-ci (ou même à celui-ci) lorsque vous souhaitez vous rappeler comment faire certaines choses en MEI.
+
+ Dès que vous vous serez bien familiarisé avec la MEI, nous vous invitons à partager votre expérience avec la Communauté MEI
+ et, pourquoi pas, à rédiger vous-même un tutoriel sur un aspect de la MEI qui vous intéresse particulièrement. Vous n'avez pas besoin d'être un expert pour cela - il est bon d'avoir des tutoriels à différents niveaux. Très souvent un tutoriel rédigé par d'autres débutants qui viennent de maîtriser une tâche
+ est plus facile à suivre qu'un guide écrit par une personne plus expérimentée qui,, ayant complètement assimilé certains éléments, ne se souvient pas qu'ils aient pu être difficile à comprendre des éléments.
+ Nous avons un tutoriel sur la rédaction de tutoriels,
+ et nous proposons des modèles à suivre. C'est facile de devenir un membre actif de la Communauté MEI :-)
+
diff --git a/_tutorials-FR/102_incipit/step-01/102_incipit_step-01-desc.html b/_tutorials-FR/102_incipit/step-01/102_incipit_step-01-desc.html
new file mode 100644
index 00000000..ca56d2c1
--- /dev/null
+++ b/_tutorials-FR/102_incipit/step-01/102_incipit_step-01-desc.html
@@ -0,0 +1,17 @@
+
+
Première étape : encoder le squelette structurel de l'exemple.
+
+
Pour encoder la ligne mélodique de cet exemple, vous devrez inclure des informations sur l'organisation de la partition et des portées.
+ En MEI, ce type d'information est donné avec les éléments <scoreDef> (définition de partition), <staffGrp>
+ (groupe de portées) et <staffDef> (définition de portée). Ainsi, <scoreDef> est utilisé pour spécifier
+ les paramètres communs d'une partition, <staffGrp> fournit des informations sur le regroupement des portées, et
+ <staffDef> contient toutes les informations liées à une portée individuelle. Ensemble, ces éléments fournissent
+ le contexte structurel du contenu musical, par exemple des informations sur le nombre de portées, leur regroupement ou leur ordre, Ainsi
+ que sur la clef, l'armure ou l'indication de mesure.
+
+
+
+
Pour l'instant, commençons avec le squelette de la structure.
+
+
Dans l'éditeur ci-dessous, Entrez un élément <scoreDef> (définition de partition) qui contient un élément enfant <staffGrp> (groupe de portées) et son élément enfant <staffDef> (définition de portée). Pour obtenir une sortie visuelle (un rendu) de l'encodage, d'autres informations devront être fournies dans les prochaines étapes.
Deuxième étape : ajoutez des attributs au squelette structurel que vous avez créé à l'étape précédente. Ces attributs fourniront
+ des informations de base sur la portée, la clef et la tonalité de l'exemple.
+
+
Vous avez appris dans l'étape précédente que l'élément <scoreDef> est utilisé pour spécifier les paramètres communs d'une partition, et
+ <staffDef> contient toutes les métadonnées relatives à une portée individuelle. Évidemment, il n'y a qu'une seule portée dans cet exemple
+ d'incipit, il serait donc possible de déclarer l'armure (3 bémols) et l'indication de mesure (mesure à 2/2) dans <staffDef>. Mais déplaçons
+ ces informations dans <scoreDef>, en supposant que la tonalité et la mesure sont les mêmes pour tous les autres instruments ou parties de la
+ partition complète de l'Opus 1 de Halvorsen. Pour spécifier une certaine tonalité ou mesure, vous devez utiliser les attributs suivants de <scoreDef>
+ et les ajouter à l'élément <scoreDef> :
+
+
@key.sig (l'armure) – le nombre de dièses/bémols à l'armure écrite, utilisez "3f" pour 3 bémols.
+
@meter.sym (indication de mesure) – utilisez "cut" pour une mesure à 2/2 (C/).
+
+
+
+
+
La clef, quant à elle, est décrite dans l'élément <staffDef>, car elle est liée à la portée individuelle (d'autres instruments peuvent avoir d'autres clefs).
+ Vous devez utiliser les attributs suivants de <staffDef> :
+
+
@n (un nombre ordinal) – représente la position de la portée dans le <staffGrp>, utilisez "1" pour la première (et unique) portée
+
@lines – représente le nombre de ligne de la portée. Utilisez "5" pour une portée à cinq lignes
+
@clef.shape – représente le symbole de la clef. Utilisez "G" pour un symbole de clef de sol.
+
@clef.line – représente la position de la clef dans la portée (en comptant à partir du bas). Utilisez "2".
+
+
+
Ajoutez les attributs décrits ci-dessus et leurs valeurs respectives à <scoreDef> et <staffDef> dans l'éditeur ci-dessous.
+ (Pour une représentation, il est encore nécessaire de fournir quelques informations supplémentaires. Nous touchons au but !)
+
+
PS : Si vous n'êtes pas très familier avec XML : Chaque fois que nous faisons référence à des attributs, nous préfixons leur nom avec le signe @. C'est une pratique courante qui provient du langage XPath. Lorsque vous les écrivez en XML, vous ne devez pas inclure le signe @, mais écrire uniquement le nom de l'attribut. N'hésitez pas à consulter notre tutoriel sur les bases de XML.
+
diff --git a/_tutorials-FR/102_incipit/step-02/102_incipit_step-02-prefill.xml b/_tutorials-FR/102_incipit/step-02/102_incipit_step-02-prefill.xml
new file mode 100644
index 00000000..fa186612
--- /dev/null
+++ b/_tutorials-FR/102_incipit/step-02/102_incipit_step-02-prefill.xml
@@ -0,0 +1,5 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/_tutorials-FR/102_incipit/step-02/102_incipit_step-02.xml b/_tutorials-FR/102_incipit/step-02/102_incipit_step-02.xml
new file mode 100644
index 00000000..1b67c1a4
--- /dev/null
+++ b/_tutorials-FR/102_incipit/step-02/102_incipit_step-02.xml
@@ -0,0 +1,25 @@
+
+
+
+
+ March
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/102_incipit/step-03/102_incipit_step-03-desc.html b/_tutorials-FR/102_incipit/step-03/102_incipit_step-03-desc.html
new file mode 100644
index 00000000..dae5f0dd
--- /dev/null
+++ b/_tutorials-FR/102_incipit/step-03/102_incipit_step-03-desc.html
@@ -0,0 +1,25 @@
+
+
Troisième étape: La configuration d'une balise <mesure> avec une balise et une balise vides.
+
Bien joué ! Vous avez déclaré les métadonnées nécessaires concernant la structure de la partition et de la mise en page des portées.
+ Avant de pouvoir encoder la première note de l'exemple, vous devrez préparer sa structure, c'est-à-dire sa mesure,
+ sa portée et sa voix.
+
+
+ En MEI, l'élément <section> est le conteneur des éléments <measure> et il est positionné
+ directement après la définition de la partition (élément <scoreDef>). Les éléments <measure>
+ peuvent contenir plusieurs portées (éléments <staff>) qui peuvent avoir plusieurs couches (éléments
+ <layer>). L'élément <layer> sera l'élément parent des éléments <note>
+ à l'étape suivante.
+
+
+ Pour indiquer la position numérotée des mesures, des portées ou des couches, l'attribut @n peut être utilisé.
+
+
Configurer la première mesure : Dans l'éditeur, insérez un élément <section>. À l'intérieur de
+ <section>, ajoutez un élément <measure> vide et définissez le numéro de la mesure de
+ départ à "0". Ajoutez un élément enfant <staff> à l'élément <measure> et définissez son
+ numéro à "1" (première portée dans la mesure 0). Ensuite, ajoutez un élément enfant non numéroté <layer>
+ à l'élément <staff>.
+
+
PS : Avec les informations nécessaires fournies dans les éléments et , le rendu est désormais capable
+ de visualiser l'encodage. Vous pouvez jouer un peu avec les valeurs des attributs de et pour voir comment
+ ils influencent le rendu.
+ Quatrième étape: Encoder la première note de cet exemple.
+
+
+
+ Après avoir préparé la structure de la mesure de départ dans l'étape précédente,
+ vous êtes maintenant prêt à encoder la première note de l'exemple. En MEI, les notes décrivent des événements de hauteur unique qui
+ sont encodés dans, *roulement de tambour*, des éléments <note>, lesquels peuvent être des enfants de
+ l'élément <layer>. Vous pouvez définir les principales caractéristiques de la note, telles que la hauteur et la durée,
+ en utilisant les attributs suivants sur l'élément <note>:
+
+
+
+
+ @pname (nom de la hauteur) – lettres minuscules de “a” à “g”, utilisez “b” ici.
+
+
+ @oct (octave) – valeur de l'octave de la hauteur en entiers de “0” à ”9”, C4 étant la hauteur
+ spécifiée par la clé de do, utilisez “3”
+
+
+ @dur (durée) – par exemple, “1” pour la ronde, “2” pour la blanche, “4” pour la
+ noire, “8” pour la croche, “16” pour la double croche, … “2048” pour la deux mille
+ quarante-huitième, utilisez “4”
+
+
+
+
+ Voici un exemple de la manière d'encoder une ronde C4 : <note pname="c" oct="4" dur="1"></note>.
+
+
+
+ Dans l'éditeur ci-dessous, saisissez l'encodage de la première note de l'exemple à l'intérieur de l'élément <layer>.
+
+
+
+ PS : Si vous êtes intéressé par un tutoriel uniquement sur les éléments <note>, consultez notre
+ tutoriel de démarrage rapide.
+
+ Cinquième étape: combinez ce que vous avez appris dans les deux étapes précédentes, encodez à la fois la structure de la prochaine
+ mesure et la seconde note de l'exemple.
+
+
+
+ Dans l'éditeur ci-dessous, ajoutez un nouvel élément <measure> avec l'attribut @n="1" et une portée
+ (<staff>) également avec l'attribut @n="1", le tout à côté de la mesure d'entrée existante.
+ Ajoutez la deuxième note de l'exemple (une noire mi bémol 4) à cette nouvelle mesure. Ne vous inquiétez pas si le contenu de la
+ mesure est trop court dans la métrique donnée - vous le compléterez dans les prochaines étapes.
+
+
+
+ PS : L'encodage sera rendu dès que vous aurez saisi la nouvelle note.
+
+ Sixième étape: encodez un groupe de notess liées par des croches.
+
+
+
+ Bien ! Pour exprimer, en MEI, un groupe de notes liées par des croches, il faut utiliser l'élément <beam>.
+ <beam> est un conteneur pour une série d'événements explicitement liés (comme des notes, des silences ou
+ des accords) qui commencent et se terminent dans la même mesure.
+
+
+
+
+ Dans l'éditeur ci-dessous, ajoutez un élément <beam> à l'emplacement spécifié avant d'ajouter les deux éléments
+ enfants <note> séparément (mi bémol et sol). N'oubliez pas d'inclure les valeurs d'attributs correspondantes dans
+ les éléments <note>.
+
+ Les deux notes suivantes dans notre exemple introduisent une nouvelle figure rythmique, une noire pointée et une croche. Pour encoder
+ un rythme pointé, vous avez besoin de l'attribut @dots de l'élément <note>. Le nombre de points est
+ défini par la valeur de cet attribut, par exemple “1” pour un point ou “2” pour deux points.
+
+
+
+ Encodez le reste de la mesure (@n=1) dans l'éditeur ci-dessous en ajoutant deux éléments <note>
+ avec différentes valeurs rythmiques (noire pointée, croche) près de l'élément <beam> que vous aviez ajouté à
+ l'étape précédente.
+
+ Huituème étape : encodez la mesure suivante en répétant tout ce que nous avons appris dans les étapes précédentes.
+
+
+
+ Encodez la prochaine mesure (@n=2) dans l'éditeur ci-dessous. Ajoutez un élément <measure> et
+ un <staff> ainsi qu'un <layer> pour contenir quatre éléments enfants :
+ une noire <note> (mi bémol 4), un élément <beam> avec deux croches <note>s
+ (mi bémol 4, sol 4) et une noire pointée <note> (si bémol 4) avec une croche <note> (sol 4).
+
+
+ Pour apporter un peu de challenge, l'éditeur ne vous proposera pas de contenu prérempli cette fois-ci. Vous n'avez donc pas d'orientation à partir
+ de l'encodage des mesures précédentes. En cas d'oubli, vous pouvez consulter les indices sous la zone de l'éditeur pour vous guider.
+
Neuvième étape : Encodez les valeurs des notes des deux dernières mesures de l'exemple.
+
+
Merveilleux, vous avez encodés la deuxième mesure ! Maintenant, nous allons augmenter un peu le niveau de difficulté : les deux
+ dernières mesures vous attendent. Mais ne vous inquiétez pas : c'est l'étape la plus ambitieuse de ce tutoriel. Promis !
+
+
Pour encoder les deux dernières mesures, vous devrez connaître un autre élément : une pause est encodée avec un élément
+ <rest> ayant un attribut @dur similaire à l'élément <note>. Mais, bien sûr,
+ un <rest> n'a ni les attributs @pname ni @oct. Vous pouvez ignorer les éléments
+ supplémentaires, tels que les dynamiques, les liaisons ou les accents à ce stade, car ils seront traités séparément dans les
+ prochaines étapes finales.
+
+
Encodez les deux dernières mesures (@n=3 et @n=4) de l'exemple dans l'éditeur ci-dessous.
+ Ajoutez les éléments <measure>, <staff> et <layer> ainsi que les éléments
+ correspondants <note>, <beam> ou <rest>. Gardez à l'esprit comment
+ l'élément <beam> est utilisé pour regrouper les éléments <note> correspondants.
+
+
Encore une fois, il n'y a pas de contenu prérempli dans la zone de l'éditeur pour cette étape. Si vous vous sentez perdu ou
+ incertain à un moment donné, suivez les indices qui s'affichent sous la zone de l'éditeur. Cela devrait vous aider.
Dixième étape : ajoutez les signes d'articulation à votre encodage de l'exemple.
+
+
Formidable ! Vous avez encodés l'intégralité de la ligne mélodique de notre exemple. Maintenant, occupons nous
+ des éléments additionnels manquants, comme les dynamiques, les liaisons et les accents.
+
+
Les articulations, par exemple les indications sur la manière de jouer une note ou un accord, peuvent être encodé
+ avec l'élement <artic> qui s'applique comme élément enfant de l'élement <note>.
+ Les attributs suivants de <artic> seront utilisés dans cette étape :
+
+
@artic (type d'articulation) – Le type d'articulation, par exemple l'accent “acc”,
+ le staccato “stacc”, le tenuto “ten”. Ici, utilisez “acc”
+
@place – La position du signe d'articulation“above” (au-dessus) ou “below” (dessous) la portée.
+ Ici, utilisez “above”
+
+
+
Trouvez les éléments <note> dans l'exemple auxquel des articulations sont attribuées (il y a des accents musicaux
+ sur les noires pointées dans les mesures 1 et 2 ainsi que sur la noire dans la mesure 3). Ajoutez un élément enfant
+ <artic> à ces éléments <note> et appliquez les attributs (@artic,
+ @place) correspondants.
Onzième étape : ajoutez les indications de nuances dans l'encodage de l'exemple.
+
+
Les nuances sont définies avec l'élement <dynam>. L'élément <dynam> peut être utilisé
+ pour les différentes indications de nuances comme “p”,
+ “mf”, ou “cresc. poco a poco”.
+ Ils sont placés en texte brut entre les balises ouvrante et fermante de l'élément <dynam>, exemple :
+ <dynam>pp</dynam>.
+
+
Au contraire des signes d'articulation, l'élément <dynam> est un évènement de contrôle qui
+ regroupes différents éléments (commes les nuances, les liaisons, les phrasés, les indications de pédales, etc.), qui dépendent
+ d'autres événements, tels que les notes ou les silences, pour être valide.
+ En général, les évènements de contrôle ne sont pas encodés commes des éléments enfants des évènements qu'ils ont sous
+ leur contrôle.
+ En practique, ils sont, dans la plupart des cas, placés à l'extérieur de l'élément staff.
+
+
Il y a différentes options pour indiquer qu'un évènements de contrôle comme <dynam> se réfère à un
+ élément <note> ou <rest> :
+
+
+
En premier lieu, <staff> auquel l'événement de contrôle doit être appliqué peut être référencé par
+ un attribut @staff.
+
De plus, le point de départ d'une indication de nuance doit être indiqué soit par un attribut startid, soit par un
+ tstamp, un tstamp.ges, ou encore un tstamp.real. Parrallèlement, le point final peut être
+ indiqué soit par un attribut dur, par dur.ges, un endid, ou un tstamp2.
+ Ne pas spécifier d'attribut pour le point de départ est une erreur sémantique.
+
+
+
Dans cet exemple, l'attribut @tstamp sert à indiquer la position de départ de l'indication de nuance.
+ @tstamp peut servir à encoder le début du temps, par exemple d'un battement, tel qu'exprimé dans la signature rythmique.
+
+
Les attributs suivants font partie de ceux qui peuvent être utilisés avec <dynam>:
+
+
@staff – L'identification du numéro de portée à laquelle un élément est appliqué, dans notre cas, par exemple, il s'agit de “1”
+
@tstamp ("time stamp") – Le début d'un évènement en matière de temps musical c'est à dire les temps, par exemple “1”, “2.5”
+
@place – La position de l'indication de nuance, “above” (au-dessus) ou “below” (en-dessous) de la portée.
+
+
+
Trouvez les éléments <note> dans l'exemple auquel des indications de nuances sont attribuées. Ajoutez un élément "frère" (c'est-à-dire qui partage le même élément parent) <dynam> à l'élément <staff> correspondant et appliquez les attributs en question (@staff, @tstamp, @place). N'oubliez pas d'inclure le signe ff entre la balise d'ouverture et de fermeture de <dynam>.
Step twelve: adding the last missing detail of the example, the slur in the third measure.
+
+
There are two different ways to encode a slur in MEI:
+
+
@slur attribute on <note> or <chord> with a value of i=initial, m=medial or
+ t=terminal.
+
A separate <slur> element.
+
+
+
In this last step, you will use the second approach: Like dynamics, <slur> elements are control events. They are not encoded as child elements of the corresponding events that they are meant to control but are placed in most cases outside the staff elements.
+
+
To indicate the starting point and end point of the slur, it is possible to apply a reference to the corresponding @xml:id of a <note> or
+ <chord> element. @xml:ids are identifiers with an arbitrary but unique character sequence that regularize the naming of an element throughout a document
+ and thus facilitate building links between elements and other resources. For <slur>s, a reference to the @xml:id of an element can be given via the
+ attributes @startid and @endid.
+
+
Along with @startid and @endid, the following attributes should be used in this step:
+
+
@staff – the identification number of the staff to which an element is applied, e.g. “1” in this case,
+
@curvedir (curve direction) – describes a curve with a generic term indicating the direction of curvature: “above”, “below” or “mixed”,
+
@startid – reference to the xml:id of the start note of the slur, in the form: #xml:id (note the hash #),
+
@endid – reference to the xml:id of the ending note of the slur, in the form: #xml:id (note the hash #).
+
+
+
Please identify the first and the last note to which the slur is attached (inside the first <beam> element of measure 3) and add @xml:ids to both <note> elements. Set a unique value for each @xml:id, for this example you can use the values: “d1e4614”, “d1e4615”. Add a <slur> control element after the closing tag of <staff> element and apply the corresponding attributes.
+
+
+ Douzième étape : ajouttez le dernier détail manquant de l'exemple, la liaison dans la troisième mesure.
+
+
Il existe deux façons différentes d'encoder une liaison en MEI :
+
+
L'attribut @slur sur <note> ou sur <chord> avec une valeur de i=initial, m=medial ou
+ t=terminal.
+
Un élément séparé <slur>.
+
+
+
Dans cette dernière étape, vous utiliserez la deuxième approche : comme les nuances, les éléments <slur> sont des événements de contrôle. Ils ne sont pas
+ encodés en tant qu'éléments enfants des événements correspondants qu'ils sont censés contrôler, mais sont placés dans la plupart des cas à l'extérieur des éléments staff.
+
+
Pour indiquer le point de départ et le point d'arrivée de la liaison, il est possible d'appliquer une référence au @xml:id correspondant d'un élément <note> ou
+ <chord>. Les @xml:id sont des identifiants avec une séquence de caractères arbitraire mais unique qui normalisent la dénomination d'un élément tout au long d'un document
+ et facilitent ainsi la création de liens entre les éléments et d'autres ressources. Pour les <slur>, une référence au @xml:id d'un élément peut être donnée via les
+ attributs @startid et @endid.
+
+
En plus de @startid et @endid, les attributs suivants devraient être utilisés dans cette étape :
+
+
@staff – le numéro d'identification de la portée à laquelle un élément est appliqué, par exemple “1” dans ce cas,
+
@curvedir (direction de la courbe) – décrit une courbe avec un terme générique indiquant la direction de la courbure : “above”, “below” ou “mixed”,
+
@startid – référence au xml:id de la note de départ de la liaison, sous la forme : #xml:id (notez bien le dièse # dans le code),
+
@endid – référence au xml:id de la note de fin de la liaison, sous la forme : #xml:id (notez bien le dièse # dans le code).
+
+
+
Identifiez la première et la dernière note à laquelle la liaison est attachée (à l'intérieur du premier élément <beam> de la mesure 3) et ajoutez des @xml:id aux deux éléments <note>. Définissez une valeur unique pour chaque @xml:id, pour cet exemple, vous pouvez utiliser les valeurs : “d1e4614”, “d1e4615”. Ajoutez un élément de contrôle <slur> après la balise de fermeture de l'élément <staff> et appliquez les attributs correspondants.
+
+
diff --git a/_tutorials-FR/102_incipit/step-12/102_incipit_step-12-prefill.xml b/_tutorials-FR/102_incipit/step-12/102_incipit_step-12-prefill.xml
new file mode 100644
index 00000000..881bb896
--- /dev/null
+++ b/_tutorials-FR/102_incipit/step-12/102_incipit_step-12-prefill.xml
@@ -0,0 +1,21 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/102_incipit/step-12/102_incipit_step-12.xml b/_tutorials-FR/102_incipit/step-12/102_incipit_step-12.xml
new file mode 100644
index 00000000..2f379bfb
--- /dev/null
+++ b/_tutorials-FR/102_incipit/step-12/102_incipit_step-12.xml
@@ -0,0 +1,94 @@
+
+
+
+
+ March
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ff
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/103_chords/103_Chords.md b/_tutorials-FR/103_chords/103_Chords.md
new file mode 100644
index 00000000..2c819944
--- /dev/null
+++ b/_tutorials-FR/103_chords/103_Chords.md
@@ -0,0 +1,7 @@
+---
+layout: tutorials-FR
+type: tutorial-FR
+name: "DÉBUTANT : Accords"
+fullname: "Un court tutoriel sur les accords en MEI"
+data: "103_chords.json"
+---
diff --git a/_tutorials-FR/103_chords/103_chord-little-lamb.png b/_tutorials-FR/103_chords/103_chord-little-lamb.png
new file mode 100644
index 00000000..4ed53a35
Binary files /dev/null and b/_tutorials-FR/103_chords/103_chord-little-lamb.png differ
diff --git a/_tutorials-FR/103_chords/103_chord-sequence.png b/_tutorials-FR/103_chords/103_chord-sequence.png
new file mode 100644
index 00000000..60f1e924
Binary files /dev/null and b/_tutorials-FR/103_chords/103_chord-sequence.png differ
diff --git a/_tutorials-FR/103_chords/103_chords.json b/_tutorials-FR/103_chords/103_chords.json
new file mode 100644
index 00000000..06286d17
--- /dev/null
+++ b/_tutorials-FR/103_chords/103_chords.json
@@ -0,0 +1,203 @@
+{
+ "steps": [
+ {
+ "label":"Bienvenue",
+ "descFile": "103_chords_step-00-desc.html"
+ },
+ {
+ "label":"Préparation",
+ "editorLines":3,
+ "descFile": "103_chords_step-01-desc.html",
+ "prefillFile": "103_chords_step-01-prefill.xml",
+ "xmlFile": "103_chords_step-01.xml",
+ "xpaths": [
+ {"rule":"count(//mei:note) = 3", "renderanyway": false, "hint": "You need three note elements."},
+ {"rule":"count(//mei:note[1]/@*) = 3 and //mei:note[1]/@pname and //mei:note[1]/@oct and //mei:note[1]/@dur", "renderanyway": false, "hint": "You need three attributes on the first note (@pname, @oct, and @dur)."},
+ {"rule":"count(//mei:note[2]/@*) = 3 and //mei:note[2]/@pname and //mei:note[2]/@oct and //mei:note[2]/@dur", "renderanyway": false, "hint": "You need three attributes on the second note (@pname, @oct, and @dur)."},
+ {"rule":"count(//mei:note[3]/@*) = 3 and //mei:note[3]/@pname and //mei:note[3]/@oct and //mei:note[3]/@dur", "renderanyway": false, "hint": "You need three attributes on the third note (@pname, @oct, and @dur)."},
+ {"rule":"//mei:note/@pname", "renderanyway": false, "hint": "The @pname attribute allows values from 'a' to 'g'."},
+ {"rule":"//mei:note/@oct", "renderanyway": false, "hint": "The @oct attribute requires integers."},
+ {"rule":"//mei:note/@dur", "renderanyway": false, "hint": "The @dur attribute allows values such as '1', '2', '4', '8'…"},
+ {"rule":"//mei:note[1]/@pname = 'e'", "renderanyway": true, "hint": "You need a @pname attribute with a value of e on the first note element."},
+ {"rule":"//mei:note[1]/@oct = '4'", "renderanyway": true, "hint": "You need an @oct attribute with a value of 4 on the first note element."},
+ {"rule":"//mei:note[1]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the first note element."},
+ {"rule":"//mei:note[2]/@pname = 'g'", "renderanyway": true, "hint": "You need a @pname attribute with a value of g on the second note element."},
+ {"rule":"//mei:note[2]/@oct = '4'", "renderanyway": true, "hint": "You need an @oct attribute with a value of 4 on the second note element."},
+ {"rule":"//mei:note[2]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the second note element."},
+ {"rule":"//mei:note[3]/@pname = 'c'", "renderanyway": true, "hint": "You need a @pname attribute with a value of c on the third note element."},
+ {"rule":"//mei:note[3]/@oct = '5'", "renderanyway": true, "hint": "You need an @oct attribute with a value of 5 on the third note element."},
+ {"rule":"//mei:note[3]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the third note element."}
+ ]
+ },
+ {
+ "label":"Premier accord",
+ "editorLines":5,
+ "descFile": "103_chords_step-02-desc.html",
+ "prefillFile": "103_chords_step-02-prefill.xml",
+ "xmlFile": "103_chords_step-02.xml",
+ "xpaths": [
+ {"rule":"count(//mei:note) = 3", "renderanyway": false, "hint": "You need three note elements."},
+ {"rule":"//mei:note[1]/@pname and //mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct)."},
+ {"rule":"//mei:note[2]/@pname and //mei:note[2]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct)."},
+ {"rule":"//mei:note[3]/@pname and //mei:note[3]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct)."},
+ {"rule":"//mei:note/@pname", "renderanyway": false, "hint": "The @pname attribute allows values from 'a' to 'g'."},
+ {"rule":"//mei:note/@oct", "renderanyway": false, "hint": "The @oct attribute requires integers."},
+ {"rule":"//mei:note[@pname = 'e' and @oct = '4']", "renderanyway": true, "hint": "You need a note with a @pname attribute with a value of e and an @oct attribute with a value of 4."},
+ {"rule":"//mei:note[@pname = 'g' and @oct = '4']", "renderanyway": true, "hint": "You need a note with a @pname attribute with a value of g and an @oct attribute with a value of 4."},
+ {"rule":"//mei:note[@pname = 'c' and @oct = '5']", "renderanyway": true, "hint": "You need a note with a @pname attribute with a value of c and an @oct attribute with a value of 5."},
+ {"rule":"count(//mei:chord) = 1", "renderanyway": false, "hint": "You need one chord element."},
+ {"rule":"//mei:chord/mei:note", "renderanyway": false, "hint": "chord element has to enclose all the note elements."},
+ {"rule":"count(//mei:note[1]/@*) = 2", "renderanyway": true, "hint": "You need only two attributes on the first note (@pname, @oct)."},
+ {"rule":"count(//mei:note[2]/@*) = 2", "renderanyway": true, "hint": "You need only two attributes on the second note (@pname, @oct)."},
+ {"rule":"count(//mei:note[3]/@*) = 2", "renderanyway": true, "hint": "You need only two attributes on the third note (@pname, @oct)."},
+ {"rule":"count(//mei:chord/@*) = 1 and //mei:chord/@dur", "renderanyway": true, "hint": "You need one attribute on the chord (@dur)."},
+ {"rule":"//mei:chord/@dur", "renderanyway": true, "hint": "The @dur attribute allows values such as '1', '2', '4', '8'…"},
+ {"rule":"//mei:chord/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the chord element."}
+ ]
+ },
+ {
+ "label":"Progression d'accords simple",
+ "editorLines":20,
+ "descFile": "103_chords_step-03-desc.html",
+ "prefillFile": "103_chords_step-03-prefill.xml",
+ "xmlFile": "103_chords_step-03.xml",
+ "xpaths": [
+ {"rule":"count(//mei:chord) = 4", "renderanyway": true, "hint": "You need four chord elements."},
+ {"rule":"count(//mei:chord[1]/@*) = 1 and //mei:chord[1]/@dur", "renderanyway": true, "hint": "You need one attribute on the first chord (@dur)."},
+ {"rule":"//mei:chord[1]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the first chord element."},
+ {"rule":"count(//mei:chord[2]/@*) = 1 and //mei:chord[2]/@dur", "renderanyway": true, "hint": "You need one attribute on the second chord (@dur)."},
+ {"rule":"//mei:chord[2]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the second chord element."},
+ {"rule":"count(//mei:chord[3]/@*) = 1 and //mei:chord[3]/@dur", "renderanyway": true, "hint": "You need one attribute on the third chord (@dur)."},
+ {"rule":"//mei:chord[3]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the third chord element."},
+ {"rule":"count(//mei:chord[4]/@*) = 1 and //mei:chord[4]/@dur", "renderanyway": true, "hint": "You need one attribute on the last chord (@dur)."},
+ {"rule":"//mei:chord[4]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the last chord element."},
+
+ {"rule":"count(//mei:chord[1]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the first chord."},
+ {"rule":"count(//mei:chord[1]/mei:note[1]/@*) = 2 and //mei:chord[1]/mei:note[1]/@pname and //mei:chord[1]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the first chord."},
+ {"rule":"//mei:chord[1]/mei:note[@pname = 'e' and @oct = '4']", "renderanyway": true, "hint": "In the first chord, you need a note with a @pname attribute with a value of e and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[1]/mei:note[2]/@*) = 2 and //mei:chord[1]/mei:note[2]/@pname and //mei:chord[1]/mei:note[2]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the first chord."},
+ {"rule":"//mei:chord[1]/mei:note[@pname = 'g' and @oct = '4']", "renderanyway": true, "hint": "In the first chord, you need a note with a @pname attribute with a value of g and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[1]/mei:note[3]/@*) = 2 and //mei:chord[1]/mei:note[3]/@pname and //mei:chord[1]/mei:note[3]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the first chord."},
+ {"rule":"//mei:chord[1]/mei:note[@pname = 'c' and @oct = '5']", "renderanyway": true, "hint": "In the first chord, you need a note with a @pname attribute with a value of c and an @oct attribute with a value of 5."},
+
+
+ {"rule":"count(//mei:chord[2]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the second chord."},
+ {"rule":"count(//mei:chord[2]/mei:note[1]/@*) = 2 and //mei:chord[2]/mei:note[1]/@pname and //mei:chord[2]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the second chord."},
+ {"rule":"//mei:chord[2]/mei:note[@pname = 'f' and @oct = '4']", "renderanyway": true, "hint": "In the second chord, you need a @pname attribute with a value of f and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[2]/mei:note[2]/@*) = 2 and //mei:chord[2]/mei:note[2]/@pname and //mei:chord[2]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the second chord."},
+ {"rule":"//mei:chord[2]/mei:note[@pname = 'a' and @oct = '4']", "renderanyway": true, "hint": "In the second chord, you need a @pname attribute with a value of a and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[2]/mei:note[3]/@*) = 2 and //mei:chord[2]/mei:note[3]/@pname and //mei:chord[2]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the second chord."},
+ {"rule":"//mei:chord[2]/mei:note[@pname = 'c' and @oct = '5']", "renderanyway": true, "hint": "In the second chord, you need a @pname attribute with a value of c and an @oct attribute with a value of 5."},
+
+
+ {"rule":"count(//mei:chord[3]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the third chord."},
+ {"rule":"count(//mei:chord[3]/mei:note[1]/@*) = 2 and //mei:chord[3]/mei:note[1]/@pname and //mei:chord[3]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the third chord."},
+ {"rule":"//mei:chord[3]/mei:note[@pname = 'd' and @oct = '4']", "renderanyway": true, "hint": "In the third chord, you need a @pname attribute with a value of d and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[3]/mei:note[2]/@*) = 2 and //mei:chord[3]/mei:note[2]/@pname and //mei:chord[3]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the third chord."},
+ {"rule":"//mei:chord[3]/mei:note[@pname = 'g' and @oct = '4']", "renderanyway": true, "hint": "In the third chord, you need a @pname attribute with a value of g and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[3]/mei:note[3]/@*) = 2 and //mei:chord[3]/mei:note[3]/@pname and //mei:chord[3]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the third chord."},
+ {"rule":"//mei:chord[3]/mei:note[@pname = 'b' and @oct = '4']", "renderanyway": true, "hint": "In the third chord, you need a @pname attribute with a value of b and an @oct attribute with a value of 4."},
+
+ {"rule":"count(//mei:chord[4]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the fourth chord."},
+ {"rule":"count(//mei:chord[4]/mei:note[1]/@*) = 2 and //mei:chord[4]/mei:note[1]/@pname and //mei:chord[4]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the fourth chord."},
+ {"rule":"//mei:chord[4]/mei:note[@pname = 'e' and @oct = '4']", "renderanyway": true, "hint": "In the fourth chord, you need a @pname attribute with a value of e and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[4]/mei:note[2]/@*) = 2 and //mei:chord[4]/mei:note[2]/@pname and //mei:chord[4]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the fourth chord."},
+ {"rule":"//mei:chord[4]/mei:note[@pname = 'g' and @oct = '4']", "renderanyway": true, "hint": "In the fourth chord, you need a @pname attribute with a value of g and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[4]/mei:note[3]/@*) = 2 and //mei:chord[4]/mei:note[3]/@pname and //mei:chord[4]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the fourth chord."},
+ {"rule":"//mei:chord[4]/mei:note[@pname = 'c' and @oct = '5']", "renderanyway": true, "hint": "In the fourth chord, you need a @pname attribute with a value of c and an @oct attribute with a value of 5."}
+ ]
+ },
+ {
+ "label":"Progression d'accord étendue",
+ "editorLines":35,
+ "descFile": "103_chords_step-04-desc.html",
+ "prefillFile": "103_chords_step-04-prefill.xml",
+ "xmlFile": "103_chords_step-04.xml",
+ "xpaths": [
+ {"rule":"count(//mei:chord) = 7", "renderanyway": true, "hint": "You need seven chord elements."},
+ {"rule":"count(//mei:chord[1]/@*) = 2 and //mei:chord[1]/@dur and //mei:chord[1]/@dots", "renderanyway": true, "hint": "You need two attributes on the first chord (@dur, @dots)."},
+ {"rule":"//mei:chord[1]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the first chord element."},
+ {"rule":"//mei:chord[1]/@dots = '1'", "renderanyway": true, "hint": "You need a @dots attribute with a value of 1 on the first chord element."},
+ {"rule":"count(//mei:chord[2]/@*) = 1 and //mei:chord[2]/@dur", "renderanyway": true, "hint": "You need one attribute on the second chord (@dur)."},
+ {"rule":"//mei:chord[2]/@dur = '8'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 8 on the second chord element."},
+ {"rule":"count(//mei:chord[3]/@*) = 1 and //mei:chord[3]/@dur", "renderanyway": true, "hint": "You need one attribute on the third chord (@dur)."},
+ {"rule":"//mei:chord[3]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the third chord element."},
+ {"rule":"count(//mei:chord[4]/@*) = 1 and //mei:chord[4]/@dur", "renderanyway": true, "hint": "You need one attribute on the fourth chord (@dur)."},
+ {"rule":"//mei:chord[4]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the fourth chord element."},
+ {"rule":"count(//mei:chord[5]/@*) = 1 and //mei:chord[5]/@dur", "renderanyway": true, "hint": "You need one attribute on the fifth chord (@dur)."},
+ {"rule":"//mei:chord[5]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the fifth chord element."},
+ {"rule":"count(//mei:chord[6]/@*) = 1 and //mei:chord[6]/@dur", "renderanyway": true, "hint": "You need one attribute on the sixth chord (@dur)."},
+ {"rule":"//mei:chord[6]/@dur = '4'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 4 on the sixth chord element."},
+ {"rule":"count(//mei:chord[7]/@*) = 1 and //mei:chord[7]/@dur", "renderanyway": true, "hint": "You need one attribute on the last chord (@dur)."},
+ {"rule":"//mei:chord[7]/@dur = '2'", "renderanyway": true, "hint": "You need a @dur attribute with a value of 2 on the last chord element."},
+
+ {"rule":"count(//mei:chord[1]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the first chord."},
+ {"rule":"count(//mei:chord[1]/mei:note[1]/@*) = 2 and //mei:chord[1]/mei:note[1]/@pname and //mei:chord[1]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the first chord."},
+ {"rule":"//mei:chord[1]/mei:note[@pname = 'g' and @oct = '4']", "renderanyway": true, "hint": "In the first chord, you need a note with a @pname attribute with a value of g and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[1]/mei:note[2]/@*) = 2 and //mei:chord[1]/mei:note[2]/@pname and //mei:chord[1]/mei:note[2]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the first chord."},
+ {"rule":"//mei:chord[1]/mei:note[@pname = 'c' and @oct = '5']", "renderanyway": true, "hint": "In the first chord, you need a note with a @pname attribute with a value of c and an @oct attribute with a value of 5."},
+ {"rule":"count(//mei:chord[1]/mei:note[3]/@*) = 2 and //mei:chord[1]/mei:note[3]/@pname and //mei:chord[1]/mei:note[3]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the first chord."},
+ {"rule":"//mei:chord[1]/mei:note[@pname = 'e' and @oct = '5']", "renderanyway": true, "hint": "In the first chord, you need a note with a @pname attribute with a value of e and an @oct attribute with a value of 5."},
+
+ {"rule":"count(//mei:chord[2]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the second chord."},
+ {"rule":"count(//mei:chord[2]/mei:note[1]/@*) = 2 and //mei:chord[2]/mei:note[1]/@pname and //mei:chord[2]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the second chord."},
+ {"rule":"//mei:chord[2]/mei:note[@pname = 'f' and @oct = '4']", "renderanyway": true, "hint": "In the second chord, you need a @pname attribute with a value of f and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[2]/mei:note[2]/@*) = 2 and //mei:chord[2]/mei:note[2]/@pname and //mei:chord[2]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the second chord."},
+ {"rule":"//mei:chord[2]/mei:note[@pname = 'b' and @oct = '4']", "renderanyway": true, "hint": "In the second chord, you need a @pname attribute with a value of b and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[2]/mei:note[3]/@*) = 2 and //mei:chord[2]/mei:note[3]/@pname and //mei:chord[2]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the second chord."},
+ {"rule":"//mei:chord[2]/mei:note[@pname = 'd' and @oct = '5']", "renderanyway": true, "hint": "In the second chord, you need a @pname attribute with a value of d and an @oct attribute with a value of 5."},
+
+ {"rule":"count(//mei:chord[3]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the third chord."},
+ {"rule":"count(//mei:chord[3]/mei:note[1]/@*) = 2 and //mei:chord[3]/mei:note[1]/@pname and //mei:chord[3]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the third chord."},
+ {"rule":"//mei:chord[3]/mei:note[@pname = 'e' and @oct = '4']", "renderanyway": true, "hint": "In the third chord, you need a @pname attribute with a value of e and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[3]/mei:note[2]/@*) = 2 and //mei:chord[3]/mei:note[2]/@pname and //mei:chord[3]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the third chord."},
+ {"rule":"//mei:chord[3]/mei:note[@pname = 'g' and @oct = '4']", "renderanyway": true, "hint": "In the third chord, you need a @pname attribute with a value of g and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[3]/mei:note[3]/@*) = 2 and //mei:chord[3]/mei:note[3]/@pname and //mei:chord[3]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the third chord."},
+ {"rule":"//mei:chord[3]/mei:note[@pname = 'c' and @oct = '5']", "renderanyway": true, "hint": "In the third chord, you need a @pname attribute with a value of c and an @oct attribute with a value of 5."},
+
+ {"rule":"count(//mei:chord[4]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the fourth chord."},
+ {"rule":"count(//mei:chord[4]/mei:note[1]/@*) = 2 and //mei:chord[4]/mei:note[1]/@pname and //mei:chord[4]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the fourth chord."},
+ {"rule":"//mei:chord[4]/mei:note[@pname = 'f' and @oct = '4']", "renderanyway": true, "hint": "In the fourth chord, you need a @pname attribute with a value of f and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[4]/mei:note[2]/@*) = 2 and //mei:chord[4]/mei:note[2]/@pname and //mei:chord[4]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the fourth chord."},
+ {"rule":"//mei:chord[4]/mei:note[@pname = 'b' and @oct = '4']", "renderanyway": true, "hint": "In the fourth chord, you need a @pname attribute with a value of b and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[4]/mei:note[3]/@*) = 2 and //mei:chord[4]/mei:note[3]/@pname and //mei:chord[4]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the fourth chord."},
+ {"rule":"//mei:chord[4]/mei:note[@pname = 'd' and @oct = '5']", "renderanyway": true, "hint": "In the fourth chord, you need a @pname attribute with a value of d and an @oct attribute with a value of 5."},
+
+ {"rule":"count(//mei:chord[5]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the fifth chord."},
+ {"rule":"count(//mei:chord[5]/mei:note[1]/@*) = 2 and //mei:chord[5]/mei:note[1]/@pname and //mei:chord[5]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the fifth chord."},
+ {"rule":"//mei:chord[5]/mei:note[@pname = 'g' and @oct = '4']", "renderanyway": true, "hint": "In the fifth chord, you need a note with a @pname attribute with a value of g and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[5]/mei:note[2]/@*) = 2 and //mei:chord[5]/mei:note[2]/@pname and //mei:chord[5]/mei:note[2]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the fifth chord."},
+ {"rule":"//mei:chord[5]/mei:note[@pname = 'c' and @oct = '5']", "renderanyway": true, "hint": "In the fifth chord, you need a note with a @pname attribute with a value of c and an @oct attribute with a value of 5."},
+ {"rule":"count(//mei:chord[5]/mei:note[3]/@*) = 2 and //mei:chord[5]/mei:note[3]/@pname and //mei:chord[5]/mei:note[3]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the fifth chord."},
+ {"rule":"//mei:chord[5]/mei:note[@pname = 'e' and @oct = '5']", "renderanyway": true, "hint": "In the fifth chord, you need a note with a @pname attribute with a value of e and an @oct attribute with a value of 5."},
+
+ {"rule":"count(//mei:chord[6]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the sixth chord."},
+ {"rule":"count(//mei:chord[6]/mei:note[1]/@*) = 2 and //mei:chord[6]/mei:note[1]/@pname and //mei:chord[6]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the sixth chord."},
+ {"rule":"//mei:chord[6]/mei:note[@pname = 'g' and @oct = '4']", "renderanyway": true, "hint": "In the sixth chord, you need a note with a @pname attribute with a value of g and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[6]/mei:note[2]/@*) = 2 and //mei:chord[6]/mei:note[2]/@pname and //mei:chord[6]/mei:note[2]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the sixth chord."},
+ {"rule":"//mei:chord[6]/mei:note[@pname = 'c' and @oct = '5']", "renderanyway": true, "hint": "In the sixth chord, you need a note with a @pname attribute with a value of c and an @oct attribute with a value of 5."},
+ {"rule":"count(//mei:chord[6]/mei:note[3]/@*) = 2 and //mei:chord[6]/mei:note[3]/@pname and //mei:chord[6]/mei:note[3]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the sixth chord."},
+ {"rule":"//mei:chord[6]/mei:note[@pname = 'e' and @oct = '5']", "renderanyway": true, "hint": "In the sixth chord, you need a note with a @pname attribute with a value of e and an @oct attribute with a value of 5."},
+
+ {"rule":"count(//mei:chord[7]/mei:note) = 3", "renderanyway": true, "hint": "You need three note elements for the last chord."},
+ {"rule":"count(//mei:chord[7]/mei:note[1]/@*) = 2 and //mei:chord[7]/mei:note[1]/@pname and //mei:chord[7]/mei:note[1]/@oct", "renderanyway": true, "hint": "You need two attributes on the first note (@pname, @oct) of the last chord."},
+ {"rule":"//mei:chord[7]/mei:note[@pname = 'g' and @oct = '4']", "renderanyway": true, "hint": "In the last chord, you need a note with a @pname attribute with a value of g and an @oct attribute with a value of 4."},
+ {"rule":"count(//mei:chord[7]/mei:note[2]/@*) = 2 and //mei:chord[7]/mei:note[2]/@pname and //mei:chord[7]/mei:note[2]/@oct", "renderanyway": true, "hint": "You need two attributes on the second note (@pname, @oct) of the last chord."},
+ {"rule":"//mei:chord[7]/mei:note[@pname = 'c' and @oct = '5']", "renderanyway": true, "hint": "In the last chord, you need a note with a @pname attribute with a value of c and an @oct attribute with a value of 5."},
+ {"rule":"count(//mei:chord[7]/mei:note[3]/@*) = 2 and //mei:chord[7]/mei:note[3]/@pname and //mei:chord[7]/mei:note[3]/@oct", "renderanyway": true, "hint": "You need two attributes on the third note (@pname, @oct) of the last chord."},
+ {"rule":"//mei:chord[7]/mei:note[@pname = 'e' and @oct = '5']", "renderanyway": true, "hint": "In the last chord, you need a note with a @pname attribute with a value of e and an @oct attribute with a value of 5."}
+ ]
+ }
+ ],
+ "end":"103_chords_end.html",
+ "resp":[
+ {
+ "name":"Stefan Münnich",
+ "affiliation":"Anton Webern Gesamtausgabe | University of Basel"
+ },
+ {
+ "name":"Johannes Kepper",
+ "affiliation":"Beethovens Werkstatt | Universität Paderborn"
+ }
+ ]
+}
diff --git a/_tutorials-FR/103_chords/103_chords_end.html b/_tutorials-FR/103_chords/103_chords_end.html
new file mode 100644
index 00000000..53ae9cef
--- /dev/null
+++ b/_tutorials-FR/103_chords/103_chords_end.html
@@ -0,0 +1,44 @@
+
+
Félicitations!
+
+ Vous venez de complétez ce tutoriel sur les accords en MEI et vous devriez
+ être maintenant capable d'encoder des progressions d'accords en MEI.
+
+
+ Bien sûr, beaucoup plus d'informations sont nécessaires pour un fichier MEI
+ complet - nous avons omis toutes les informations structurelles sur les
+ mesures et les portées, et vous devez également apprendre à configurer la
+ mesure, la tonalité et les clefs. Comme prochaines étapes dans votre
+ apprentissage de la MEI, nous aimerions vous recommander notre tutoriel sur
+ les
+ silences. Bien sûr, vous pouvez toujours revenir à ceux-ci (ou même à celui-ci)
+ lorsque vous souhaitez vous rappeler comment faire certaines choses en MEI.
+
+
+ Dès que vous vous serez bien familiarisé avec la MEI, nous vous invitons à
+ partager votre expérience avec la
+ Communauté MEI
+ et, pourquoi pas, à rédiger vous-même un tutoriel sur un aspect de la MEI
+ qui vous intéresse particulièrement. Vous n'avez pas besoin d'être un expert
+ pour cela - il est bon d'avoir des tutoriels à différents niveaux. Très
+ souvent un tutoriel rédigé par d'autres débutants qui viennent de maîtriser
+ une tâche est plus facile à suivre qu'un guide écrit par une personne plus
+ expérimentée qui, ayant complètement assimilé certains éléments, ne se
+ souvient pas qu'ils aient pu être difficile à comprendre des éléments. Nous
+ avons un
+ tutoriel sur la rédaction de tutoriels, et nous proposons des modèles à suivre. C'est facile de devenir un membre
+ actif de la Communauté MEI
+
+
diff --git a/_tutorials-FR/103_chords/step-00/103_chords_step-00-desc.html b/_tutorials-FR/103_chords/step-00/103_chords_step-00-desc.html
new file mode 100644
index 00000000..aae2d886
--- /dev/null
+++ b/_tutorials-FR/103_chords/step-00/103_chords_step-00-desc.html
@@ -0,0 +1,26 @@
+
+
Dans ce tutoriel, vous apprendrez comment encoder des accords en MEI.
+
+ Étant donné que le concept d'accord repose fortement sur les notes, nous
+ vous recommandons de vous familiariser avec l'encodage des notes avant ce
+ tutoriel, par exemple dans notre
+ tutoriel de démarrage rapide.
+
+
+ Le code que vous écrirez sera immédiatement rendu, et le rendu réagira à vos
+ modifications. De cette façon, vous aurez une idée de la manière dont les
+ différents paramètres interagissent.
+
+
+ Une fois que vous aurez terminé ce tutoriel, vous pourrez effectuer d'autres
+ tutoriels qui vous présenteront d'autres aspects importants de la MEI. Ces
+ tutoriels servent également de référence simple pour la MEI – vous pouvez
+ toujours y revenir.
+
+
+ Pour commencer, appuyez sur le bouton "Continuer" en bas à droite de ce
+ paragraphe.
+
+
diff --git a/_tutorials-FR/103_chords/step-01/103_chords_step-01-desc.html b/_tutorials-FR/103_chords/step-01/103_chords_step-01-desc.html
new file mode 100644
index 00000000..cf58ff75
--- /dev/null
+++ b/_tutorials-FR/103_chords/step-01/103_chords_step-01-desc.html
@@ -0,0 +1,106 @@
+
+
Step one: provide some notes for a chord.
+
+ In MEI, the notion of a chord means the "simultaneous sounding of two or
+ more notes in the same layer with the same duration" (see
+ Element specification). Thus, a chord is made up of two or more note elements that belong to the
+ same voice (layer) and have an identical rhythmical structure (duration).
+ (There are cases where you don't want to have the same duration on every
+ note of a chord, but these are not part of this basic tutorial.)
+
+
+ To encode such a "simultaneous sounding", the
+ <chord> element is used in MEI. Its use is pretty
+ straightforward: Multiple <note> elements within the same
+ layer are enclosed by a <chord> element and the duration
+ attribute (@dur) is moved from the <note>s to the
+ <chord> element (since the duration is the same for all
+ notes). However, whether you write an outer
+ <chord> element first to add some inner
+ <note> elements, or whether you start with the
+ <note>s and then enclose them in a
+ <chord> element, does not actually matter in practice.
+
+
+ For this tutorial, let's stick to the second approach: This means, we need
+ some notes first.
+
+
+ In the editor below, please enter the following three
+ <note> elements:
+
+
+
+
<note pname="e" oct="4" dur="4"/>
+
<note pname="g" oct="4" dur="4"/>
+
<note pname="c" oct="5" dur="4"/>
+
+
+
+ You should then see the three notes rendered sequentially. Not much of a
+ chord, actually. But don't worry: We will care about that right away in the
+ next step. Until then, you may play a little bit with the attribute values
+ to see how they influence the rendering. You will also see hints on how to
+ write the correct code. Whenever you're ready, make sure to have the correct
+ code in the editor, and then hit the "continue" button on the lower right.
+
+
+
+ Première étape : fournir quelques notes pour un accord.
+
+
+ En MEI, la notion d'un accord signifie la "production simultanée de deux
+ notes ou plus dans la même couche avec la même durée" (voir
+ la spécification de l'élément). Ainsi, un accord est composé de deux notes ou plus appartenant à la même
+ voix (couche) et ayant une structure rythmique identique (durée). (Il existe
+ des cas où vous ne souhaitez pas avoir la même durée pour chaque note d'un
+ accord, mais cela ne fait pas partie de ce tutoriel de base.)
+
+
+ Pour encoder une telle "production simultanée", l'élément
+ <chord> est utilisé en MEI. Son utilisation est assez
+ simple : plusieurs éléments <note> dans la même couche
+ sont inclus dans un élément <chord> et l'attribut de
+ durée (@dur) est déplacé des <note> vers l'élément
+ <chord> (puisque la durée est la même pour toutes les
+ notes). Cependant, que vous écriviez d'abord un élément
+ <chord> externe pour ajouter des éléments
+ <note> internes, ou que vous commenciez par les
+ <note>s et les enfermiez ensuite dans un élément
+ <chord>, n'a, en pratique, aucune importance.
+
+
+ Pour ce tutoriel, restons à la deuxième approche : cela signifie que nous
+ avons d'abord besoin de quelques notes.
+
+
+ Dans l'éditeur ci-dessous, entrez les trois éléments
+ <note> suivants :
+
+
+
+
<note pname="e" oct="4" dur="4"/>
+
<note pname="g" oct="4" dur="4"/>
+
<note pname="c" oct="5" dur="4"/>
+
+
+
+ Vous devriez ensuite voir les trois notes rendues séquentiellement. À ce
+ stade, ce n'est pas vraiment un accord. Mais ne vous inquiétez pas : nous
+ nous en occuperons dans l'étape suivante. D'ici là, vous pouvez jouer avec
+ les valeurs des attributs pour voir comment elles influencent le rendu. Vous
+ verrez également des indices sur la manière d'écrire le code correct. Quand
+ vous serez prêt, assurez-vous d'avoir le code correct dans l'éditeur, puis
+ appuyez sur le bouton "Continuer" en bas à droite.
+
+
diff --git a/_tutorials-FR/103_chords/step-01/103_chords_step-01-prefill.xml b/_tutorials-FR/103_chords/step-01/103_chords_step-01-prefill.xml
new file mode 100644
index 00000000..3ac128b2
--- /dev/null
+++ b/_tutorials-FR/103_chords/step-01/103_chords_step-01-prefill.xml
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/_tutorials-FR/103_chords/step-01/103_chords_step-01.xml b/_tutorials-FR/103_chords/step-01/103_chords_step-01.xml
new file mode 100644
index 00000000..e49836f7
--- /dev/null
+++ b/_tutorials-FR/103_chords/step-01/103_chords_step-01.xml
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/103_chords/step-02/103_chords_step-02-desc.html b/_tutorials-FR/103_chords/step-02/103_chords_step-02-desc.html
new file mode 100644
index 00000000..2c65c93f
--- /dev/null
+++ b/_tutorials-FR/103_chords/step-02/103_chords_step-02-desc.html
@@ -0,0 +1,29 @@
+
+
Deuxième étape : encodez un accord (une triade).
+
+ Bien joué ! Il est maintenant temps de créer un élément
+ "<chord>"" avec ces trois <note>s.
+ Comme mentionné dans l'étape précédente, vous devriez enfermer les éléments
+ de note dans un élément de chord et déplacer les attributs de durée des
+ notes vers le chord.
+
+
+ Dans l'éditeur ci-dessous, enfermez les trois
+ éléments <note> dans un
+ élément <chord> (c'est-à-dire insérez la balise
+ d'ouverture de <chord> avant la première note et la
+ balise de fermeture après la dernière). Les trois notes simples devraient
+ maintenant être rendues non pas séquentiellement, mais alignées
+ verticalement, mais elles n'ont pas encore la bonne durée. Supprimez donc
+ les attributs de durée de toutes les notes et ajoutez-en un au
+ <chord> à la place. Gardez la durée d'une noire
+ (@dur="4").
+
+
+ Vous devriez alors voir le rendu de l'accord. Encore une fois, vous pouvez
+ jouer avec les valeurs des attributs pour voir comment elles influencent le
+ rendu. Vous verrez également des indications sur la manière d'écrire le code
+ correct. Quand vous serez prêt, assurez-vous d'avoir le code correct dans
+ l'éditeur, puis appuyez sur le bouton "Continuer" en bas à droite.
+
+ Parfait, vous venez d'encoder un accord en MEI. Maintenant continuons et
+ ajoutons quelques accords supplémentaires pour encoder une suite d'accords :
+
+
+
+ Dans l'éditeur ci-dessous, essayez de reproduire la suite d'accord ci-dessus
+ en MEI. Les notes sont enfermées par les éléments constitutif d'un accord.
+ Chaque accord a besoin d'un attribut @dur et chaque note a
+ besoin des attributs @pname et @oct.
+
+ Étape quatre : encoder une séquence étendue d'accords.
+
+
+ Parfait, vous venez d'encoder une séquence d'accords simple en MEI.
+ Maintenant, continuons et ajoutons une certaine variance rythmique pour une
+ séquence d'accords plus étendue. En fait, nous allons parvenir à une
+ harmonisation de l'exemple "Mary had a little lamb" du
+ tutoriel de démarrage rapide
+ :
+
+
+
+
+ Dans l'éditeur ci-dessous, veuillez essayer de reproduire la séquence
+ d'accords ci-dessus avec MEI. Les notes sont incluses dans des éléments
+ d'accord. Chaque accord a besoin d'un attribut
+ @dur, et chaque note a besoin des attributs
+ @pname et @oct.
+
+
+ Gardez à l'esprit que l'attribut @dur peut avoir des valeurs
+ comme "1", "2", "4",
+ "8" ou "16" pour indiquer différentes valeurs
+ rythmiques. Pour le premier accord, vous avez besoin d'un attribut
+ supplémentaire @dots, où vous devez spécifier le nombre de
+ points en tant qu'entier - dans ce cas, c'est simplement
+ dots="1".
+
+
+ Astuce : Une fois que vous avez établi la structure d'accords, vous devriez
+ être en mesure de copier-coller le bloc avec les trois éléments
+ <note>.
+
+
diff --git a/_tutorials-FR/103_chords/step-04/103_chords_step-04-prefill.xml b/_tutorials-FR/103_chords/step-04/103_chords_step-04-prefill.xml
new file mode 100644
index 00000000..8c14d778
--- /dev/null
+++ b/_tutorials-FR/103_chords/step-04/103_chords_step-04-prefill.xml
@@ -0,0 +1,5 @@
+
+
+
+
+
diff --git a/_tutorials-FR/103_chords/step-04/103_chords_step-04.xml b/_tutorials-FR/103_chords/step-04/103_chords_step-04.xml
new file mode 100644
index 00000000..12909226
--- /dev/null
+++ b/_tutorials-FR/103_chords/step-04/103_chords_step-04.xml
@@ -0,0 +1,68 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/104_rests/104_rests-multirest.png b/_tutorials-FR/104_rests/104_rests-multirest.png
new file mode 100644
index 00000000..f3be57e2
Binary files /dev/null and b/_tutorials-FR/104_rests/104_rests-multirest.png differ
diff --git a/_tutorials-FR/104_rests/104_rests-spaces.png b/_tutorials-FR/104_rests/104_rests-spaces.png
new file mode 100644
index 00000000..94dd19a4
Binary files /dev/null and b/_tutorials-FR/104_rests/104_rests-spaces.png differ
diff --git a/_tutorials-FR/104_rests/104_rests.json b/_tutorials-FR/104_rests/104_rests.json
new file mode 100644
index 00000000..23dbdb73
--- /dev/null
+++ b/_tutorials-FR/104_rests/104_rests.json
@@ -0,0 +1,71 @@
+{
+ "steps": [
+ {
+ "label":"Bienvenue",
+ "descFile": "104_rests_step-00-desc.html",
+ "xmlFile": "104_rests_step-00.xml",
+ "editorLines":1,
+ "xpaths": [
+ {"rule":"count(//mei:rest) = 1", "renderanyway": false, "hint": "Vous avez besoin d'un élément 'rest'"},
+ {"rule":"count(//mei:rest/@*) = 1 and //mei:rest/@dur", "renderanyway": false, "hint": "Vous avez besoin d'un attribut @dur."},
+ {"rule":"//mei:rest/@dur = '4'", "renderanyway": true, "hint": "L'attribut @dur utilise des valeurs comme '1','2', ou '4'. Utilisez ce dernier pour un soupir."}
+ ]
+ },
+ {
+ "label":"Les différentes durées de silences",
+ "editorLines":5,
+ "descFile": "104_rests_step-01-desc.html",
+ "xmlFile": "104_rests_step-00.xml",
+ "xpaths": [
+ {"rule":"count(//mei:rest) = 5", "renderanyway": true, "hint":"Vous devez encoder 5 éléments 'rest'."},
+ {"rule":"//mei:rest[1]/@dur and //mei:rest[1]/@dur = '1'", "renderanyway": true},
+ {"rule":"//mei:rest[2]/@dur and //mei:rest[2]/@dur = '2'", "renderanyway": true},
+ {"rule":"//mei:rest[3]/@dur and //mei:rest[3]/@dur = '4' and //mei:rest[3]/@dots and //mei:rest[3]/@dots = '1'", "renderanyway": true},
+ {"rule":"//mei:rest[4]/@dur and //mei:rest[4]/@dur = '8'", "renderanyway": true},
+ {"rule":"//mei:rest[5]/@dur and //mei:rest[5]/@dur = '16'", "renderanyway": true}
+ ]
+ },
+ {
+ "label":"La pause (mesure pleine)",
+ "editorLines":1,
+ "descFile": "104_rests_step-02-desc.html",
+ "xmlFile": "104_rests_step-02.xml",
+ "prefillFile": "104_rests_step-02-prefill.xml",
+ "xpaths": [
+ {"rule":"count(//mei:mRest) = 1", "renderanyway": true, "hint":"Il vous faut un élément mRest."},
+ {"rule":"count(//mei:mRest/@*) = 0", "renderanyway": true,"hint":"L'élément mRest n'a pas besoin d'attributs"},
+ {"rule":"count(//mei:layer/mei:*) = 1","renderanyway":true,"hint":"Vous devez seulement encoder un élément'mRest'."}
+ ]
+ },
+ {
+ "label":"Silences sur mesure multiple",
+ "editorLines":1,
+ "descFile": "104_rests_step-03-desc.html",
+ "xmlFile": "104_rests_step-02.xml",
+ "xpaths": [
+ {"rule":"count(//mei:multiRest) = 1", "renderanyway": true, "hint":"Il vous faut un élément multiRest."},
+ {"rule":"count(//mei:layer/mei:*) = 1","renderanyway":true,"hint":"Vous devez seulement encoder un élément 'multiRest'."},
+ {"rule":"count(//mei:multiRest/@*) = 1 and //mei:multiRest/@num", "renderanyway": true,"hint":"L'élément multiRest a besoin d'un seul attribut ici (@num)."},
+ {"rule":"//mei:multiRest/@num = '15'", "renderanyway": true,"hint":"L'élément multiRest doit avoir une durée de 15 mesures"}
+ ]
+ },
+ {
+ "label":"Espaces et silences invisibles",
+ "editorLines":6,
+ "descFile": "104_rests_step-04-desc.html",
+ "xmlFile": "104_rests_step-04.xml",
+ "prefillFile": "104_rests_step-04-prefill.xml",
+ "xpaths": [
+ {"rule":"//mei:space/following-sibling::mei:note", "renderanyway": true, "hint":"Un élément 'space' doit précédé un élément 'note'."},
+ {"rule":"count(//mei:space[@dur = '4']) = 3 or (//mei:space[@dur = '2' and @dots = '1']) or (//mei:space[@dur = '2'] and //mei:space[@dur = '4'])", "renderanyway": true}
+ ]
+ }
+ ],
+ "end":"104_rests_end.html",
+ "resp":[
+ {
+ "name":"Johannes Kepper",
+ "affiliation":"Beethovens Werkstatt | Universität Paderborn"
+ }
+ ]
+}
diff --git a/_tutorials-FR/104_rests/104_rests.md b/_tutorials-FR/104_rests/104_rests.md
new file mode 100644
index 00000000..67333ff1
--- /dev/null
+++ b/_tutorials-FR/104_rests/104_rests.md
@@ -0,0 +1,7 @@
+---
+layout: tutorials-FR
+type: tutorial-FR
+name: "DÉBUTANT : Silences"
+fullname: "Un court tutoriel sur les silences en MEI"
+data: "104_rests.json"
+---
diff --git a/_tutorials-FR/104_rests/104_rests.png b/_tutorials-FR/104_rests/104_rests.png
new file mode 100644
index 00000000..1fa00cc4
Binary files /dev/null and b/_tutorials-FR/104_rests/104_rests.png differ
diff --git a/_tutorials-FR/104_rests/104_rests_end.html b/_tutorials-FR/104_rests/104_rests_end.html
new file mode 100644
index 00000000..8acb38c4
--- /dev/null
+++ b/_tutorials-FR/104_rests/104_rests_end.html
@@ -0,0 +1,27 @@
+
+
Félicitations!
+
+ Dans ce tutoriel, vous venez d'apprendre à encoder les silences avec la MEI. Les éléments que vous avez appris sont :
+
+ Ces éléments sont presque toujours vides et n'ont pas d'éléments enfants. Avec l'élément d'espace, vous avez déjà appris
+ un mécanisme assez avancé d'alignement de plusieurs voix partageant une portée en MEI. Si cela vous intéresse, vous voudrez
+ peut-être également vous renseigner sur les attributs @next et @prev de la classe d'attributs de la MEI,
+ att.linking
+ (disponible sur <note> et d'autres événements). Cette classe d'attributs permet de laisser des "miettes de pain"
+ à travers un fichier MEI, ce qui permet de suivre des voix à travers plusieurs couches (et portées, si nécessaire). Cela faciliterait
+ l'utilisation analytique de votre fichier MEI, mais ce n'est pas nécessaire dans la plupart des situations.
+
+
\ No newline at end of file
diff --git a/_tutorials-FR/104_rests/step-00/104_rests_step-00-desc.html b/_tutorials-FR/104_rests/step-00/104_rests_step-00-desc.html
new file mode 100644
index 00000000..8611567e
--- /dev/null
+++ b/_tutorials-FR/104_rests/step-00/104_rests_step-00-desc.html
@@ -0,0 +1,37 @@
+
+
+ Dans ce tutoriel, vous apprendrez à encoder différents types de silences du
+ répertoire de la notation musicale classique en utilisant la MEI.
+
+ Selon la
+ Spécification MEI, un silence est "un événement non sonore trouvé dans la source en cours de
+ transcription". Son encodage est simple : utilisez simplement un élément
+ <rest>, avec un attribut @dur.
+
+ Félicitations, vous venez d'encoder votre premier silence. Le suivant sera
+ tout aussi facile :
+
+
+ Encodez une séquence de cinq silences :
+
+
+
+ Pour le troisième silence, vous avez besoin d'un attribut supplémentaire
+ @dots, où vous devez spécifier le nombre de points en tant
+ qu'entier - dans ce cas, c'est simplement dots="1". Gardez à
+ l'esprit que l'attribut @dur peut avoir des valeurs comme
+ "1", "2", "4", "8" ou
+ "16".
+
+ Très souvent, un silence est censé remplir une mesure complète,
+ indépendamment de la mesure. Bien sûr, il est possible d'utiliser des
+ éléments <rest> réguliers avec la ou les durées
+ appropriées pour cela – dans le cas d'une mesure de 4/4, cela serait
+ simplement un <rest dur="1"/>. Cependant, dans d'autres
+ mesures, cela peut nécessiter plus de balisage. Pour cette raison, MEI a un
+ élément spécial appelé <mRest/> – un
+ silence de mesure. Cet élément n'a pas besoin d'un attribut
+ @dur (même s'il est techniquement autorisé pour faciliter le
+ traitement analytique) et remplira toujours une mesure complète,
+ indépendamment de la mesure. Par conséquent, vous ne devriez pas le combiner
+ avec d'autres événements dans la même mesure.
+
+
+ Transformez le silence entier (qui ne correspond pas à la mesure) en un
+ <mRest/>.
+
+
diff --git a/_tutorials-FR/104_rests/step-02/104_rests_step-02-prefill.xml b/_tutorials-FR/104_rests/step-02/104_rests_step-02-prefill.xml
new file mode 100644
index 00000000..33896b86
--- /dev/null
+++ b/_tutorials-FR/104_rests/step-02/104_rests_step-02-prefill.xml
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/_tutorials-FR/104_rests/step-02/104_rests_step-02.xml b/_tutorials-FR/104_rests/step-02/104_rests_step-02.xml
new file mode 100644
index 00000000..7ce4594e
--- /dev/null
+++ b/_tutorials-FR/104_rests/step-02/104_rests_step-02.xml
@@ -0,0 +1,32 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/104_rests/step-03/104_rests_step-03-desc.html b/_tutorials-FR/104_rests/step-03/104_rests_step-03-desc.html
new file mode 100644
index 00000000..b07cad43
--- /dev/null
+++ b/_tutorials-FR/104_rests/step-03/104_rests_step-03-desc.html
@@ -0,0 +1,20 @@
+
+
+ Souvent, dans la musique organisée en parties, il y a fréquemment des
+ silences qui durent plus d'une mesure.
+
+
+
+ En MEI, ces silences sont encodés en utilisant l'élément spécial
+ <multiRest/>. Il utilise des entiers simples dans
+ l'attribut @num pour spécifier le nombre de mesures pendant
+ lesquelles le musicien de cette partie doit se reposer.
+
+
+ Encodez un <multiRest/> d'une durée de 15 mesures.
+
+
diff --git a/_tutorials-FR/104_rests/step-04/104_rests_step-04-desc.html b/_tutorials-FR/104_rests/step-04/104_rests_step-04-desc.html
new file mode 100644
index 00000000..f776996b
--- /dev/null
+++ b/_tutorials-FR/104_rests/step-04/104_rests_step-04-desc.html
@@ -0,0 +1,72 @@
+
+
+ Lorsque la musique se décompose en plusieurs instruments ou voix qui se
+ partagent une même portée, il est parfois nécessaire de "déplacer" des
+ événements comme des notes vers une position ultérieure dans la mesure, sans
+ signifier pour autant que l'espace généré pour ce déplacement soit un
+ silence. C'est généralement le cas lorsque le document encodé alterne entre
+ une notation en accords et une représentation en notes séparées au sein
+ d'une mesure (cf. figure ci-dessous). Comme la MEI utilise l'élément
+ <layer>
+ pour disposer plusieurs instruments, et que, dans ces situations, un
+ instrument bascule d'une couche à l'autre au milieu d'une mesure, les
+ "trous" dans ces mesures doivent être comblées. C'est là que l'élément
+ <space> intervient.
+
+
+
+ Bien sûr, un espace n'est pas vraiment un silence. Cependant, les silences
+ (invisibles) sont souvent utilisés à ces fins dans d'autres formats
+ d'encodage ou éditeurs de partitions. L'avantage de l'élément
+ <space> de la MEI est qu'il n'a aucune signification
+ sémantique - il pousse simplement d'autres événements autour. Cela facilite
+ l'encodage et l'extraction de voix individuelles, car aucun élément porteur
+ d'informations inexistantes n'est introduit à tort pour une meilleure
+ coordination.
+
+
+ Cependant, vous pouvez appliquer une certaine durée à l'élément
+ <space> en utilisant l'attribut @dur. Vous
+ pouvez même utiliser @dots pour prolonger cette durée de la
+ moitié de sa valeur. La durée que vous appliquez à
+ <space> est le nombre de temps que les événements, comme
+ une <note>, suivant le <space>, sont
+ déplacés vers la droite.
+
+
+ Dans l'éditeur ci-dessous, vous voyez un encodage prérempli d'une note G4
+ (positionnée au premier temps dans la deuxième couche). Veuillez déplacer
+ cette note à la fin de la mesure, de manière à ce qu'elle se trouve sur le
+ dernier temps sous le D5, comme sur l'image ci-dessus. Pour ce faire,
+ utilisez l'élément <space> et appliquez une durée
+ appropriée (elle doit être de 3 temps au total). En fait, il existe
+ plusieurs façons de l'encoder :
+
+
+
+ avec trois <space> utilisant la même valeur pour
+ @dur,
+
+
+ avec deux éléments <space> utilisant uniquement
+ @dur, mais avec deux valeurs différentes,
+
+
+ ou même avec un seul élément <space>, utilisant
+ @dur et @dots.
+
+
+
+ Vous pouvez jouer avec les valeurs des attributs pour voir comment elles
+ influent sur le rendu. Trouverez-vous les trois solutions possibles ?
+
+
diff --git a/_tutorials-FR/104_rests/step-04/104_rests_step-04-prefill.xml b/_tutorials-FR/104_rests/step-04/104_rests_step-04-prefill.xml
new file mode 100644
index 00000000..10e4e05e
--- /dev/null
+++ b/_tutorials-FR/104_rests/step-04/104_rests_step-04-prefill.xml
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/_tutorials-FR/104_rests/step-04/104_rests_step-04.xml b/_tutorials-FR/104_rests/step-04/104_rests_step-04.xml
new file mode 100644
index 00000000..7651f114
--- /dev/null
+++ b/_tutorials-FR/104_rests/step-04/104_rests_step-04.xml
@@ -0,0 +1,43 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/180_understanding-odd/beam-module.png b/_tutorials-FR/180_understanding-odd/beam-module.png
new file mode 100644
index 00000000..6272aea2
Binary files /dev/null and b/_tutorials-FR/180_understanding-odd/beam-module.png differ
diff --git a/_tutorials-FR/180_understanding-odd/just-a-name.xml b/_tutorials-FR/180_understanding-odd/just-a-name.xml
new file mode 100644
index 00000000..be8152b8
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/just-a-name.xml
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
diff --git a/_tutorials-FR/180_understanding-odd/role-children-byclass.png b/_tutorials-FR/180_understanding-odd/role-children-byclass.png
new file mode 100644
index 00000000..5a818f86
Binary files /dev/null and b/_tutorials-FR/180_understanding-odd/role-children-byclass.png differ
diff --git a/_tutorials-FR/180_understanding-odd/role-children.png b/_tutorials-FR/180_understanding-odd/role-children.png
new file mode 100644
index 00000000..b83f1342
Binary files /dev/null and b/_tutorials-FR/180_understanding-odd/role-children.png differ
diff --git a/_tutorials-FR/180_understanding-odd/tutorials.xml b/_tutorials-FR/180_understanding-odd/tutorials.xml
new file mode 100644
index 00000000..811c8cdb
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/tutorials.xml
@@ -0,0 +1,34 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-01.html b/_tutorials-FR/180_understanding-odd/understanding-odd-01.html
new file mode 100644
index 00000000..b7f8fcd2
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-01.html
@@ -0,0 +1,49 @@
+
+
Comprendre ODD (One Document Does it all)
+
+ Ceci est un tutoriel avancé qui vise à expliquer les structures internes de
+ la MEI. En utilisant ces structures, il est possible de restreindre la MEI
+ aux exigences spécifiques et aux perspectives de n'importe quel cas
+ d'utilisation donné, ce qui est généralement considéré comme une bonne
+ pratique. Ce n'est qu'avec une version restreinte (généralement appelée
+ "personnalisée") de la MEI qu'on peut appliquer les principes éditoriaux d'un
+ projet donné, ce qui contribue à garantir techniquement la qualité des
+ données. Même si une telle validation arrête difficilement les erreurs
+ sémantiques (comme l'encodage de hauteurs de ton incorrectes, par exemple),
+ elle garantit que seul un balisage adapté au flux de travail du projet est
+ utilisé, et aucune mauvaise interprétation ne peut découler d'un balisage
+ inattendu.
+
+
+ Ce tutoriel introduira les concepts de base du langage ODD (One Document Does it all), qui est utilisé
+ pour définir MEI. Dans un deuxième tutoriel, nous introduirons des flux de
+ travail et des outils qui aident à créer des personnalisations
+ individuelles. Il est fortement recommandé de vous familiariser d'abord avec
+ les structures sous-jacentes dans ce tutoriel.
+
+
+ Certes, il s'agit de l'un des sujets les plus avancés autour de MEI, et cela
+ prend certainement du temps pour se familiariser avec l'utilisation d'ODD.
+ Cependant, la large communauté de MEI se fera un plaisir de
+ répondre à vos questions, et il en va de même pour l'équipe technique de MEI
+ Technical Team. Prenez simplement votre temps avec ce tutoriel, et examinez également de
+ plus près le
+ chapitre correspondant des directives MEI. Vous deviendrez éventuellement compétent dans la discipline d'utilisation
+ des normes DH telles que MEI - continuez simplement à partir d'ici :-)
+
+
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-02.html b/_tutorials-FR/180_understanding-odd/understanding-odd-02.html
new file mode 100644
index 00000000..8238526d
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-02.html
@@ -0,0 +1,58 @@
+
+
+ ODD, acronyme de One Document Does-it-all, fait partie de la
+ norme TEI, et est également utilisé pour définir la TEI elle-même.
+
+
+ ODD utilise un ensemble d'éléments spéciaux dans l'espace de noms
+ TEI
+ pour décrire des formats de données basés sur XML. En plus de la TEI de
+ base, il est utilisé pour des formats basés sur la TEI tels que
+ EpiDoc, mais aussi pour des formats techniquement indépendants comme la MEI. En
+ 2016, la TEI a proposé une version d'ODD appelée
+ Pure ODD. En été 2020, la MEI continue cependant d'utiliser l'ancienne version d'ODD,
+ car la nouvelle version n'apporte pas d'avantages pertinents pour la MEI, mais
+ entraînerait un travail de maintenance significatif pour divers outils et
+ flux de travail liés à la MEI.
+
+
+ La principale différence avec Pure ODD est que l'ancienne version
+ utilisée par la MEI utilise des éléments de l'espace de noms
+ RelaxNG. En fin de compte, les fichiers ODD sont généralement compilés en un
+ schéma RelaxNG (ou XSD), car il n'y a littéralement aucun support logiciel
+ pour une validation directe contre ODD. Cependant, le recours à RelaxNG dans
+ ODD ajoute une dépendance supplémentaire au flux de travail TEI, réduisant
+ ainsi la liberté technique pour définir TEI et/ou ODD à un certain degré
+ (mineur?). Comme la MEI est déjà défini dans un format qui est hors du contrôle
+ direct de la communauté MEI et doit de toute façon gérer plusieurs espaces
+ de noms XML, l'argument en faveur de la définition cohérente de tout en
+ Pure ODD est moins convaincant et n'a donc pas été suivi jusqu'à
+ présent.
+
+
\ No newline at end of file
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-03.html b/_tutorials-FR/180_understanding-odd/understanding-odd-03.html
new file mode 100644
index 00000000..e46c1111
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-03.html
@@ -0,0 +1,50 @@
+
+
+ Malgré son nom, la configuration pour travailler avec ODD nécessite
+ généralement au moins deux fichiers logiques (bien que
+ ceux-ci puissent être répartis sur de nombreux fichiers dans le système de
+ fichiers, comme illustré dans l'étape suivante de ce tutoriel). Le premier
+ de ces fichiers est le soi-disant fichier source : il contient la
+ spécification complète du format, dans ce cas MEI. Dans notre référentiel,
+ il se trouve dans le fichier
+ mei-source.xml. En plus de ce fichier, une personnalisation séparée est
+ nécessaire pour spécifier quelles parties de la spécification doivent être
+ utilisées dans un contexte donné. Le but principal de ODD est de permettre
+ des personnalisations flexibles du schéma. MEI propose un ensemble de
+ profils prédéfinis, qui ne sont rien d'autre que des personnalisations du schéma MEI.
+
+
+ Pour utiliser MEI (ou tout autre format basé sur ODD), le fichier de
+ personnalisation est utilisé pour contrôler la manière dont le
+ fichier source doit être compilé. Il existe plusieurs formats
+ cibles pour cette compilation, ce qui est expliqué ailleurs.
+ Le format cible le plus courant est un fichier
+ RelaxNG, qui contient à la fois des hiérarchies RelaxNG et des règles Schematron
+ supplémentaires telles que définies dans ODD, et peut être utilisé pour la
+ validation contre les deux types de schémas. Tous les autres formats de
+ sortie possibles ne sont pas couramment utilisés pour MEI. (Note : nous
+ reviendrons brièvement sur une explication de Schematron plus tard dans ce
+ tutoriel.)
+
+
+ Alors que ce tutoriel se concentre sur l'explication des principes de base
+ des structures ODD telles qu'on les trouve dans les sources de MEI, un
+ tutoriel séparé sur ODD expliquera comment personnaliser MEI selon des
+ besoins spécifiques. Les étapes suivantes présenteront les mécanismes des
+ principales structures ODD dans MEI : modules, éléments, modèles, attributs,
+ types de données et macros. Continuons pour examiner de plus près les
+ modules…
+
+
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-04.html b/_tutorials-FR/180_understanding-odd/understanding-odd-04.html
new file mode 100644
index 00000000..bd8c891c
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-04.html
@@ -0,0 +1,124 @@
+
+
+ La structure conceptuelle de plus haut niveau dans ODD est constituée de
+ modules. Les modules permettent de diviser le schéma en différentes
+ zones, chacune définissant un aspect clairement délimité. Jusqu'en 2019, la
+ structure des Directives MEI suivait les modules ODD, mais cette
+ configuration a été remplacée par une division plus instructive. À l'heure
+ actuelle, les modules apparaissent dans les Directives MEI en haut des
+ définitions des éléments, attributs, etc. :
+
+
+
+
+
+ Il s'agit simplement d'une référence facile aux modules. Si vous prévoyez de
+ travailler sur le MEI ODD, cependant, il est plus important de savoir que le
+ code source MEI est divisé en suivant les modules. Le fichier
+ mei-source.xml
+ sert de point de départ dans la spécification MEI. L'élément
+ <schemaSpec>
+ dans
+ la ligne 83
+ définit un nouveau schéma avec l'espace de noms MEI
+ (@ns="http://www.music-encoding.org/ns/mei"). Il a ensuite un
+ certain nombre de sous-éléments XInclude. XInclude est
+ utilisé pour diviser un fichier XML logique plus grand en fichiers plus
+ petits, plus gérables. Ici, chaque module MEI est stocké dans un fichier
+ séparé dans le
+ sous-dossier modules.
+
+
+ Les modules MEI sont construits autour de différents thèmes. Il existe des
+ modules qui se concentrent sur des répertoires musicaux spécifiques (CMN,
+ Mensural,
+ Neumes, ou
+ Tablature de cordes), mais aussi des modules pour des perspectives spécifiques sur la musique
+ (visuelle,
+ gestuelle,
+ analytique), des technologies (
+ MIDI) ou des cas d'utilisation (fac-similés,
+ performances,
+ usage éditorial). La portée de chacun de ces modules est décrite dans les Directives MEI.
+
+
+ Outre une meilleure maintenabilité du code source MEI grâce à des fichiers
+ plus petits, la division permet principalement de "désactiver" plus
+ facilement des parties plus importantes (-> modules) du schéma MEI.
+
+
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-05.html b/_tutorials-FR/180_understanding-odd/understanding-odd-05.html
new file mode 100644
index 00000000..cc30ed32
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-05.html
@@ -0,0 +1,120 @@
+
+
+ Les éléments les plus évidents pour la spécification MEI sont les
+ définitions d'éléments. Elles sont réalisées en utilisant l'élément
+ <elementSpec>
+ du TEI. Jetons un coup d'œil à l'élément
+ <castItem>
+ de MEI :
+
+
+<elementSpec ident="castItem" module="MEI.shared">
+ <desc>Contient une seule entrée dans une liste de distribution, décrivant soit un rôle unique soit une liste de rôles non parlants.</desc>
+ <classes>
+ <memberOf key="att.common"/>
+ <memberOf key="att.bibl"/>
+ <memberOf key="att.facsimile"/>
+ <memberOf key="att.lang"/>
+ </classes>
+ <content>
+ <rng:oneOrMore>
+ <rng:choice>
+ <rng:text/>
+ <rng:ref name="role" />
+ <rng:ref name="roleDesc" />
+ <rng:ref name="actor" />
+ <rng:ref name="perfRes" />
+ </rng:choice>
+ </rng:oneOrMore>
+ </content>
+ <remarks>
+ <p part="N">Cet élément est basé sur un élément dans la norme Text Encoding Initiative (TEI).</p>
+ </remarks>
+</elementSpec>
+
+
+ L'élément <castItem> a une spécification très concise qui
+ fournit néanmoins beaucoup d'informations à son sujet. Tout d'abord, le nom
+ de l'élément est spécifié dans l'attribut @ident de
+ l'élément <elementSpec>. De plus, le module auquel il appartient est
+ spécifié avec l'attribut @module. Le module
+ MEI.shared utilisé dans ce cas sert de solution de secours pour de
+ nombreux éléments génériques qui ne s'intègrent pas bien dans d'autres
+ modules ou qui sont indispensables pour utiliser MEI.
+
+
+ Nous voyons ensuite un élément <desc> qui donne une
+ explication très brève de l'objectif et de la portée de l'élément en
+ question. Cette information est souvent utilisée dans les logiciels sous
+ forme d'info-bulle pour guider un codeur dans l'utilisation des éléments
+ appropriés. Une description parlante est donc extrêmement importante.
+
+
+ La prochaine information est fournie avec l'élément
+ <classes>, qui spécifie à quelles classes
+ l'élément appartient. Nous couvrirons cela plus en détail plus tard, mais
+ pour vous donner une première compréhension : cela est utilisé pour définir
+ quelles attributs sont disponibles sur l'élément et où il peut être utilisé
+ à l'intérieur d'un fichier MEI.
+
+
+ Nous voyons maintenant l'élément <content>, qui
+ définit ce qui peut être à l'intérieur de notre élément. Ici, la
+ version de ODD utilisée par MEI bascule vers l'espace de noms
+ RelaxNG (http://relaxng.org/ns/structure/1.0), comme indiqué par le
+ préfixe rng: aux noms des éléments. Les niveaux suivants de
+ balisage peuvent être compris de manière assez intuitive à partir des noms
+ des éléments : Le contenu peut être un ou plusieurs d'un
+ choix soit de contenu textuel, soit des éléments
+ <role>,
+ <roleDesc>,
+ <actor>, ou
+ <perfRes>. L'imbrication de <rng:oneOrMore> et
+ <rng:choice> indique qu'il n'y a pas d'ordre particulier pour
+ ces éléments enfants, et qu'ils peuvent être librement mélangés avec du
+ contenu textuel.
+
+
+ Ce que nous voyons ici sont des références directes
+ (<rng:ref>) à des éléments spécifiques, identifiés par leurs
+ attributs @ident respectifs. Dans la prochaine étape de ce
+ tutoriel, nous verrons une approche plus flexible utilisant des
+ classes de modèle. Les deux approches peuvent être mélangées selon
+ les besoins.
+
+
+ La seule autre information fournie par ce <elementSpec> est
+ <remarks>. Alors que
+
+
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-06.html b/_tutorials-FR/180_understanding-odd/understanding-odd-06.html
new file mode 100644
index 00000000..cab3a746
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-06.html
@@ -0,0 +1,124 @@
+
+
+ Comme nous l'avons vu, ODD permet de spécifier quels éléments enfants exacts
+ sont autorisés à l'intérieur d'un élément donné. Cela permet un contrôle
+ très précis de la hiérarchie MEI, mais cela se fait au prix de listes très
+ verbeuses de ce que chaque élément peut contenir. Ce n'est ni
+ particulièrement maintenable ni facile à suivre : certains éléments de MEI
+ peuvent contenir des dizaines d'autres éléments, et la comparaison de deux
+ de ces éléments est plutôt fastidieuse.
+
+
+ Entre autres, l'élément
+ <castItem>
+ de la dernière étape de ce tutoriel avait un élément enfant
+ <role>. La documentation pour <role> liste un total de 54 éléments
+ enfants, plus le contenu textuel :
+
+
+
+
+
+ En regardant le <elementSpec>, il n'y a pas une telle liste,
+ cependant :
+
+
+<elementSpec ident="role" module="MEI.shared">
+ <desc>Nom d'un rôle dramatique, tel qu'il est donné dans une distribution.</desc>
+ <classes>
+ <memberOf key="att.common"/>
+ <memberOf key="att.facsimile"/>
+ <memberOf key="att.lang"/>
+ </classes>
+ <content>
+ <rng:zeroOrMore>
+ <rng:choice>
+ <rng:text/>
+ <rng:ref name="model.textPhraseLike.limited" />
+ </rng:choice>
+ </rng:zeroOrMore>
+ </content>
+ <remarks>
+ <p part="N">Cet élément est modélisé sur un élément dans la norme Text Encoding Initiative (TEI).</p>
+ </remarks>
+</elementSpec>
+
+ Au lieu des 54 éléments de la capture d'écran ci-dessus, un seul
+ <rng:ref> est donné, pointant vers quelque chose nommé
+ model.textPhraseLike.limited. Il s'agit d'une
+ classe modèle. Les classes modèles sont destinées à servir
+ de substituts pour des groupes d'éléments. La classe modèle elle-même ne
+ sait pas quels éléments en font partie :
+
+
+<classSpec ident="model.textPhraseLike.limited" module="MEI.shared" type="model">
+ <desc>Regroupe les éléments textuels qui surviennent au niveau des mots ou des phrases individuels. Cette classe est équivalente à la classe model.textPhraseLike sans l'élément pb.</desc>
+ <classes>
+ <memberOf key="model.rdgPart.text"/>
+ <memberOf key="model.editTransPart.text"/>
+ <memberOf key="model.textPhraseLike"/>
+ </classes>
+</classSpec>
+
+ Une classe modèle est encodée avec un
+ <classSpec>
+ élément, qui a l'attribut @type="model". Comme les
+ éléments, elle est identifiée de manière unique avec l'attribut
+ @ident. Elle est attribuée à l'un des modules MEI avec
+ l'attribut @module. MEI suit la convention que tous les noms de
+ classes modèle sont préfixés par la chaîne "model.". Ils ont
+ également toujours un <desc> avec une brève explication de
+ l'objectif du groupe. Passons les éléments <memberOf> sur
+ <classSpec> de l'exemple ci-dessus pour un moment, et voyons
+ comment ces 54 éléments que nous avons vus ci-dessus sont liés à
+ model.textPhraseLike.limited.
+
+
+ Si nous allons dans les directives MEI pour
+ model.textPhraseLike.limited, nous voyons que six éléments sont directement des "membres" de
+ cette classe modèle : <dedicatee>,
+ <dimensions>, <extent>, <seg>,
+ <symbol>, et <term>. Regardons
+ <dedicatee> :
+
+
+<elementSpec ident="dedicatee" module="MEI.shared">
+ <desc>Entité à qui une œuvre créative est formellement offerte.</desc>
+ <classes>
+ <-- autres affiliations supprimées pour la brièveté -->
+ <memberOf key="model.textPhraseLike.limited"/>
+ </classes>
+ <content>
+ <rng:zeroOrMore>
+ <rng:choice>
+ <rng:text/>
+ <rng:ref name="model.textPhraseLike.limited" />
+ </rng:choice>
+ </rng:zeroOrMore>
+ </content>
+ <-- constraintSpec
+
+
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-07.html b/_tutorials-FR/180_understanding-odd/understanding-odd-07.html
new file mode 100644
index 00000000..588324b0
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-07.html
@@ -0,0 +1,109 @@
+
+
+ Comme nous l'avons vu à l'étape précédente, une grande partie de la
+ hiérarchie MEI est établie grâce à l'utilisation de classes modèles. Un
+ mécanisme très similaire est utilisé par ODD pour rendre les attributs
+ disponibles sur plusieurs éléments. Mais avant de traiter des classes
+ d'attributs, jetons un bref coup d'œil sur la manière dont un attribut est
+ réellement défini dans ODD. L'attribut @xml:id est disponible sur
+ chaque élément MEI et est défini avec les spécifications suivantes :
+
+
+<attDef ident="xml:id" usage="opt">
+ <desc>Normalise le nom d'un élément et facilite ainsi la création de liens entre lui et d'autres ressources. Chaque attribut id dans un document doit avoir une valeur unique.</desc>
+ <datatype maxOccurs="1" minOccurs="1">
+ <rng:data type="ID"/>
+ </datatype>
+ </attDef>
+
+ Les attributs sont spécifiés à l'aide de l'élément
+ <attDef>
+ et suivent certaines conventions que nous avons déjà vues sur les éléments
+ et les classes modèles : leur nom est fourni dans l'attribut
+ @ident, et ils ont un élément <desc> avec une brève
+ description. Ce qui est nouveau, c'est l'attribut @usage,
+ qui spécifie quand utiliser l'attribut spécifié. La valeur ici,
+ "opt", est utilisée pour les attributs facultatifs – @xml:id
+ peut être utilisé sur tous les éléments MEI, mais ce n'est pas obligatoire.
+ D'autres valeurs autorisées pour @usage sont "req"
+ (requis) et "rec" (recommandé lorsqu'il est applicable).
+
+
+ Maintenant, regardons où se trouvent ces éléments <attDef>.
+ Même si ce n'est pas vraiment la solution préférée, parfois les attributs
+ sont définis à l'endroit où ils doivent être utilisés, comme avec l'attribut
+ @type sur
+ <meiHead>
+ :
+
+
+<elementSpec ident="meiHead" module="MEI.header">
+ <desc>(En-tête MEI) – Fournit les métadonnées descriptives et déclaratives préfixées à chaque texte conforme à MEI.</desc>
+ <classes>
+ <!-- Les éléments memberOf sont omis pour des raisons de brièveté -->
+ </classes>
+ <content>
+ <!-- Les contenus sont omis pour des raisons de brièveté -->
+ </content>
+ <!-- Les spécifications de contraintes sont omises pour des raisons de brièveté -->
+ <attList>
+ <attDef ident="type" usage="opt">
+ <desc>Spécifie le type de document auquel l'en-tête est attaché, par exemple s'il
+ s'agit d'un corpus ou d'un texte individuel.</desc>
+ <valList type="closed">
+ <valItem ident="music">
+ <desc>L'en-tête est attaché à un document musical.</desc>
+ </valItem>
+ <valItem ident="corpus">
+ <desc>L'en-tête est attaché à un corpus.</desc>
+ </valItem>
+ <valItem ident="independent">
+ <desc>L'en-tête est indépendant ; c'est-à-dire, non attaché à un document musical ou à un corpus.</desc>
+ </valItem>
+ </valList>
+ </attDef>
+ </attList>
+ <!-- Les remarques sont omises pour des raisons de brièveté -->
+</elementSpec>
+
+ Comme nous pouvons le voir, les attributs sont simplement contenus dans un
+ enfant <attList> à l'intérieur de
+ <elementSpec>. Cependant, dans la plupart des cas, un
+ attribut est censé être disponible sur plus d'un élément. L'attribut
+ @xml:id introduit ci-dessus est disponible sur chaque élément MEI,
+ il devrait donc être défini plusieurs centaines de fois – encore une fois,
+ cela n'est ni maintenable ni efficace. Au lieu de cela, ODD utilise à
+ nouveau un système de classes, cette fois-ci pour les
+ classes d'attributs. Regardons comment @xml:id est
+ réellement distribué dans MEI en utilisant la classe d'attributs
+ att.id :
+
+
+<classSpec ident="att.id" module="MEI.shared" type="atts">
+ <desc>Attributs qui identifient de manière unique un élément.</desc>
+ <attList org="group">
+ <attDef ident="xml:id" usage="opt">
+ <!-- On saute cela, car c'est exactement la même chose que dans l'exemple ci-dessus -->
+ </attDef>
+ </attList>
+</classSpec>
+
+ Nous avons déjà vu le <attDef>, et il n'y a aucune différence
+ entre les attributs définis à l'intérieur d'un élément ou à l'int
+
+
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-08.html b/_tutorials-FR/180_understanding-odd/understanding-odd-08.html
new file mode 100644
index 00000000..648d03de
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-08.html
@@ -0,0 +1,105 @@
+
+
+ La plupart des types de données dans ODD suivent des concepts courants bien
+ établis : il y a des entiers, des valeurs booléennes, des chaînes de
+ caractères, etc. Examinons de plus près certains d'entre eux. L'attribut
+ @n est défini dans la classe d'attributs
+ att.nInteger
+ :
+
+
+<attDef ident="n" usage="opt">
+ <desc>Fournit une désignation numérique indiquant la position d'un élément dans une séquence d'éléments similaires. Sa valeur doit être un entier non négatif.</desc>
+ <datatype maxOccurs="1" minOccurs="1">
+ <rng:data type="nonNegativeInteger"/>
+ </datatype>
+</attDef>
+
+ Cela utilise un élément <data> de l'espace de noms
+ rng:, où @type utilise une valeur définie dans RelaxNG.
+ Les attributs @maxOccurs et @minOccurs définissent combien
+ de fois une valeur de ce type peut être fournie. Un exemple pour d'autres
+ valeurs peut être trouvé pour l'attribut @staff défini dans
+ att.staffIdent. Cet attribut est utilisé pour associer des
+ controlevents
+ à une ou plusieurs portées, et peut contenir un ou plusieurs entiers. Il
+ utilise
+ la balise suivante
+ pour cela :
+
+ Dans d'autres cas, MEI définit ses propres types de données. Cela se fait
+ avec un élément
+ <macroSpec>. Regardons le type de données
+ data.BARRENDITION, qui est utilisé pour définir l'apparence des barres :
+
+
+<macroSpec ident="data.BARRENDITION" module="MEI" type="dt">
+ <desc>Représentations graphiques des barres. Certaines valeurs correspondent à la partie "Western Musical Symbols" du standard Unicode.</desc>
+ <content>
+ <valList type="closed">
+ <valItem ident="dashed">
+ <desc>Ligne en pointillés (Unicode 1D104).</desc>
+ </valItem>
+ <valItem ident="dotted">
+ <desc>Ligne pointillée.</desc>
+ </valItem>
+ <valItem ident="dbl">
+ <desc>(Unicode 1D101).</desc>
+ </valItem>
+ <valItem ident="dbldashed">
+ <desc>Double ligne en pointillés.</desc>
+ </valItem>
+ <valItem ident="dbldotted">
+ <desc>Double ligne pointillée.</desc>
+ </valItem>
+ <valItem ident="end">
+ <desc>(Unicode 1D102).</desc>
+ </valItem>
+ <valItem ident="invis">
+ <desc>Barre non rendue.</desc>
+ </valItem>
+ <valItem ident="rptstart">
+ <desc>Début de répétition (Unicode 1D106).</desc>
+ </valItem>
+ <valItem ident="rptboth">
+ <desc>Début et fin de répétition.</desc>
+ </valItem>
+ <valItem ident="rptend">
+ &
+
+
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-09.html b/_tutorials-FR/180_understanding-odd/understanding-odd-09.html
new file mode 100644
index 00000000..8b1060fb
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-09.html
@@ -0,0 +1,82 @@
+
+
+ Les macros sont la dernière partie de l'ODD nécessaire pour comprendre
+ pleinement les spécifications de MEI, et elles sont clairement l'aspect le
+ moins important. Les macros sont des espaces réservés pour des éléments qui
+ peuvent être ajoutés au <content> d'un élément en une seule
+ fois. La macro la plus utilisée est probablement
+ macro.struc-unstrucContent, qui est définie comme suit :
+
+ Les macros utilisent à nouveau l'élément
+ <macroSpec>, mais cette fois avec un @type ayant la valeur "pe". Les
+ noms, qui sont à nouveau stockés dans @ident, sont préfixés par
+ "macro.", et bien sûr, nous avons à nouveau une balise
+ <desc>. La principale différence par rapport aux
+ classes de modèle est que les macros ne substituent pas
+ seulement des éléments, mais aussi des règles plus complexes sur les
+ combinaisons d'éléments. Ici, macro.struc-unstrucContent fournit un
+ bon exemple. Elle force l'utilisateur à choisir entre un modèle
+ d'encodage structuré (utilisant un élément <head> dédié,
+ suivi d'une série de paragraphes) ou un modèle non structuré (où le contenu
+ textuel est inséré directement et peut être balisé avec divers éléments).
+ Elle peut être utilisée à l'intérieur d'éléments tels que
+ <watermark>, et elle est utile pour éviter de devoir
+ redéfinir la même combinaison d'éléments à de nombreux endroits.
+
+
+<elementSpec ident="watermark" module="MEI.header">
+ <desc>Contient une description d'un filigrane ou d'un dispositif similaire.</desc>
+ <classes>
+ <!-- adhésions omises pour des raisons de brièveté -->
+ </classes>
+ <content>
+ <rng:ref name="macro.struc-unstrucContent" />
+ </content>
+ <!-- remarques omises pour des raisons de brièveté -->
+</elementSpec>
+
+ En essence, le <rng:ref> à l'intérieur du
+ <elementSpec> est simplement remplacé par les éléments
+ enfants du <content> de <macroSpec>, de sorte
+ qu'il est possible de combiner une macro avec d'autres contenus.
+ Les macros servent donc de blocs de spécifications prédéfinis et
+ réutilisables.
+
+
+ Comme je l'ai mentionné plus tôt, les macros ne sont pas l'aspect
+ le plus important de l'ODD du point de vue de MEI, et vous devriez donc
+ avoir pu obtenir tout ce qui est nécessaire. Cela signifie que vous avez
+ terminé cette dernière étape. Continuons pour quelques remarques de
+ clôture...
+
+
diff --git a/_tutorials-FR/180_understanding-odd/understanding-odd-10.html b/_tutorials-FR/180_understanding-odd/understanding-odd-10.html
new file mode 100644
index 00000000..bb951ba9
--- /dev/null
+++ b/_tutorials-FR/180_understanding-odd/understanding-odd-10.html
@@ -0,0 +1,26 @@
+
+
+ Félicitations ! Vous avez réussi à parcourir avec succès
+ cette introduction à l'ODD du point de vue de MEI. Vous devriez maintenant
+ connaître et comprendre tous les éléments constitutifs de la spécification
+ MEI. Il faut l'admettre, cela a été un parcours difficile et vous devrez
+ peut-être le relire plusieurs fois pour vraiment vous familiariser. Ce qu'il
+ est important de garder à l'esprit, c'est que la version d'ODD utilisée par
+ MEI est actuellement légèrement obsolète et peut ne plus être parfaitement
+ alignée avec la documentation TEI. Néanmoins, tous les outils et flux de
+ travail MEI fonctionnent correctement avec cette version, donc du point de
+ vue de MEI, la situation actuelle n'est pas un problème.
+
+
+ La prochaine étape à partir de maintenant est d'apprendre à rédiger des
+ personnalisations MEI réelles en utilisant ODD. Il existe
+ un tutoriel distinct à ce sujet (ou il sera bientôt disponible...), qui
+ entrera dans les détails de ce processus. De telles personnalisations
+ utiliseront certains concepts supplémentaires par rapport à ce que vous avez
+ appris ici, mais il est crucial de comprendre pleinement les concepts
+ sous-jacents d'abord. Dès que vous aurez l'impression d'avoir compris ODD
+ jusqu'à présent, ce niveau supplémentaire ne devrait plus vous inquiéter. Et
+ avec des personnalisations appropriées, vous pourrez utiliser MEI de manière
+ experte pour répondre à vos besoins :)
+
+ Il s'agit d'un tutoriel avancé qui présente comment personnaliser MEI pour
+ des besoins spécifiques à un projet. Il suppose une compréhension solide des
+ structures internes d'ODD de MEI, telles que décrites dans le tutoriel
+ Comprendre ODD. Si vous n'êtes pas familier avec les éléments
+ <elementSpec>, les classes modèles et les classes d'attributs, il est probablement
+ préférable de revenir à
+ ce tutoriel
+ d'abord.
+
+
+ Commençons maintenant avec notre tutoriel actuel. Le but des
+ personnalisations est de restreindre le schéma MEI uniquement à
+ ceux des parties du cadre qui sont pertinentes pour une tâche ou un projet
+ donné. Il est également possible d'étendre MEI en utilisant les
+ mêmes mécanismes décrits ici, mais cela est laissé à un autre tutoriel. Pour
+ l'instant, l'accent est mis sur la sous-ensemble de MEI, car les fichiers
+ validés par rapport à une version personnalisée de MEI valideront également
+ par rapport au
+ MEI All, qui ressemble au cadre MEI complet. Cela garantit un niveau substantiel
+ de compatibilité avec les outils et la documentation existants. En général,
+ les extensions à MEI devraient être faites uniquement lorsque c'est
+ absolument nécessaire, et il est généralement une bonne idée, dans de telles
+ situations, de consulter la
+ communauté MEI
+ pour vérifier qu'aucune autre solution n'existe déjà.
+
+
+ Dans ce tutoriel, nous apprendrons d'abord comment utiliser le
+ MEI ProfileDrafter, qui fournit une interface utilisateur graphique pour générer des
+ personnalisations de restriction de base. Il fait partie du
+ MEI Garage, et bien qu'il soit quelque peu limité, il aide certainement à mieux
+ comprendre les concepts des personnalisations MEI. Ensuite, nous examinerons
+ la sortie du MEI ProfileDrafter et verrons comment générer un fichier
+ RelaxNG à des fins de validation à partir de cela. Enfin, nous introduirons
+ des options de personnalisation plus avancées, qui vont au-delà de la portée
+ du MEI ProfileDrafter. Vous voudrez peut-être utiliser une application
+ d'édition XML à un moment donné pour suivre, mais nous utiliserons des
+ services web pour tout le traitement, donc peu importe l'éditeur que vous
+ choisissez - tout est bien. Maintenant que c'est réglé, commençons!
+
+
diff --git a/_tutorials-FR/181_customizing_MEI/customizing-odd-02.html b/_tutorials-FR/181_customizing_MEI/customizing-odd-02.html
new file mode 100644
index 00000000..1c216f3f
--- /dev/null
+++ b/_tutorials-FR/181_customizing_MEI/customizing-odd-02.html
@@ -0,0 +1,92 @@
+
+
+ Pour les étapes suivantes, vous devriez ouvrir le
+ MEI ProfileDrafter
+ dans une fenêtre de navigateur séparée (ou un onglet) pour suivre ces
+ instructions.
+
+
+
+ Lorsque vous ouvrez le ProfileDrafter, vous verrez une liste de tous les
+ modules MEI dans la colonne centrale. Pour chacun, le nombre d'éléments et
+ de classes d'attributs dans ce module est indiqué. Les modules individuels
+ peuvent être désactivés en décochant la case à gauche de leur nom. Veuillez
+ interdire certains modules MEI en les décochant.
+
+
+ C'est assez simple de (dé)sélectionner les modules MEI, n'est-ce pas ?
+ Cependant, en n'utilisant que cette case à cocher, vous obtenez très peu de
+ retour sur les conséquences de vos choix - l'interface utilisateur ne vous
+ dit pas vraiment ce que vous retirez du schéma avec ces sélections.
+ Cependant, chaque boîte de module a également un bouton
+ personnaliser dans son coin supérieur droit. En cliquant sur ce
+ bouton, la liste des modules dans la colonne centrale est remplacée par une
+ liste de tous les éléments et classes d'attributs qui font partie du module
+ actuel. Veuillez noter que cela n'est possible que pour les modules que vous
+ n'avez pas exclus du schéma.
+
+
+ Si vous cliquez pour personnaliser le module MEI.cmnOrnaments, vous
+ verrez une liste avec les éléments <mordent>, <trill> et
+ <turn>, et les classes d'attributs att.mordent.log,
+ att.ornamentAccid, att.ornamPresent,
+ att.trill.log et att.turn.log. Encore une fois, vous
+ pouvez désélectionner n'importe lequel d'entre eux, en fonction de vos
+ besoins spécifiques. Alors que sur le dernier écran, vous avez pu désactiver
+ des modules entiers, ici vous pouvez faire des choix sélectifs, restreignant
+ MEI à vos besoins spécifiques. Si, pour une raison quelconque, vous avez
+ besoin d'une version de MEI qui vous permet d'encoder des <trill>,
+ mais qui ne prend pas en charge les <mordent> et <turn>, vous
+ pouvez facilement désactiver ces deux éléments, mais conserver le module
+ MEI.cmnOrnaments en tant que tel. En regardant des modules "plus
+ grands" comme MEI.cmn, MEI.header ou
+ MEI.edittrans, il est facile d'envisager des cas d'utilisation plus
+ pratiques pour cette exclusion sélective d'éléments.
+
+
+ Comme pour les éléments, il est possible de
+ interdire des classes d'attributs dans cette vue d'ensemble
+ du module. Cependant, cela nécessite une bonne compréhension des classes
+ disponibles et de leur hiérarchie. Pour la plupart des utilisateurs (et des
+ cas d'utilisation), il sera plus pratique de le faire d'un point de vue
+ légèrement différent. Sur chaque élément, il y a un bouton
+ définir les attributs. Si vous cliquez sur ce bouton, le contenu de
+ la colonne principale est à nouveau remplacé par un contenu différent. Cette
+ fois, vous trouverez une liste de tous les attributs disponibles sur cet
+ élément. La disposition de cette liste suit les classes d'attributs dont cet
+ élément est membre. Chaque classe d'attribut a une case à cocher qui peut
+ être utilisée pour la désactiver. Si vous désélectionnez une classe
+ d'attribut, cela ne supprimera pas seulement les attributs définis dans
+ cette classe, mais supprimera également toutes les autres classes
+ d'attributs héritées à travers la hiérarchie de classes - y compris tous les
+ attributs définis par celles-ci. Par exemple, si vous décochez la classe
+ d'attributs att.basic (qui est disponible sur chaque élément dans
+ MEI via la classe att.common), cela supprimera non seulement
+ l'attribut @xml:base, mais aussi la classe att.id, et par
+ cela l'attribut @xml:id. Après avoir fait cela sur n'importe quel
+ élément de votre choix, vous devriez naviguer vers un autre élément. Vous
+ remarquerez que la même classe d'attributs est déjà désactivée : toutes ces
+ options sont correctement coordonnées. Cela inclut les classes d'attributs
+ répertoriées au niveau des modules individuels.
+
+
+ Avec les options pour désactiver les modules, les
+ éléments individuels et des
+ classes d'attributs
+ spécifiques, il est déjà possible de restreindre considérablement le schéma
+ MEI, le rendant plus adapté aux besoins spécifiques de tout projet donné, et
+ aidant ce projet à éviter toute incohérence et autres problèmes d'encodage.
+ Comme le MEI ProfileDrafter permet de partir de plusieurs personnalisations
+ MEI officielles, il est assez simple de générer une version personnalisée de
+ MEI qui restreint davantage le profil MEI CMN (ou toute autre
+ personnalisation). Dans la prochaine étape de ce tutoriel, nous verrons
+ comment utiliser cette personnalisation.
+
+
diff --git a/_tutorials-FR/181_customizing_MEI/customizing-odd-03.html b/_tutorials-FR/181_customizing_MEI/customizing-odd-03.html
new file mode 100644
index 00000000..e007c6e3
--- /dev/null
+++ b/_tutorials-FR/181_customizing_MEI/customizing-odd-03.html
@@ -0,0 +1,70 @@
+
+
+ Dès que vous avez créé une version personnalisée restreinte de MEI avec le
+ MEI ProfileDrafter, la prochaine étape consiste à préparer votre première
+ personnalisation MEI pour la validation - vous devez la compiler en
+ un fichier RelaxNG. Bien que le ProfileDrafter proposera une version
+ compilée pour un téléchargement direct à un moment donné, nous nous
+ concentrerons sur une méthode de compilation différente qui permet de faire
+ d'autres modifications manuelles au fichier de personnalisation ODD. Dans
+ une configuration de projet professionnelle, vous voudrez également
+ versionner et documenter correctement votre personnalisation ODD - ce qui
+ est hors de portée du MEI ProfileDrafter.
+
+
+ Veuillez cliquer sur le bouton Télécharger ODD dans la colonne de
+ gauche du ProfileDrafter et enregistrez le fichier proposé à un endroit
+ pratique. Maintenant, dirigez une nouvelle fenêtre de navigateur vers le
+ Service de personnalisation MEI
+ qui fait partie de MEI Garage. Ici, vous devez sélectionner le fichier
+ source MEI sur lequel votre personnalisation est basée. Comme le
+ ProfileDrafter est actuellement limité à MEI v4.0.1, vous pouvez laisser
+ l'option par défaut dans le Service de personnalisation. La prochaine étape
+ consiste à sélectionner et télécharger votre fichier de
+ Personnalisation Locale dans la colonne centrale. Ensuite, vous
+ devez laisser l'option Sortie définie sur RelaxNG. Vous
+ pouvez maintenant cliquer sur le grand bouton Traitement en bleu.
+ Après un certain traitement côté serveur, l'étiquette de ce bouton changera
+ en Téléchargement. Dès que cela se produit, vous pouvez cliquer à
+ nouveau pour télécharger le fichier RelaxNG résultant.
+ Assurez-vous de renommer le fichier téléchargé en quelque chose de
+ significatif et utilisez l'extension .rng. Vous disposez
+ maintenant d'un fichier RelaxNG correct compilé à partir de votre
+ personnalisation ODD. Ce fichier peut être utilisé pour valider des fichiers
+ XML par rapport à votre profil personnalisé de MEI. Félicitations - vous
+ avez déjà fait des progrès significatifs dans la manière d'utiliser MEI. Une
+ version spécifiquement adaptée à vos besoins est toujours préférable à un
+ profil générique taille unique - qui est évidemment destiné comme point de
+ départ pour des ajustements plus spécifiques adaptés à vos besoins.
+
+
+ Ce tutoriel pourrait s'arrêter ici en toute sécurité. Le vrai défi est
+ d'identifier vos besoins et de les
+ modéliser en conséquence de toute façon, mais cela n'est
+ rien qui puisse être enseigné par un tutoriel en ligne. Bien que
+ l'acquisition de l'expérience nécessaire à cela dépendra du temps et des
+ échanges, vous avez déjà les compétences techniques pour aborder de bons
+ modèles.
+
+
+ Cependant, avec quelques ajustements supplémentaires à la personnalisation
+ ODD, il est possible d'exercer un contrôle encore meilleur sur le schéma
+ résultant, vous donnant un contrôle très étroit sur la validation et aidant
+ ainsi à prévenir autant que possible les erreurs de données. De tels
+ ajustements sont hors de portée du ProfileDrafter et nécessiteront donc des
+ ajustements manuels à la personnalisation ODD. À la prochaine étape, nous
+ analyserons les structures que le ProfileDrafter utilise pour supprimer des
+ modules, des éléments individuels et des
+ classes d'attributs de MEI.
+
+
diff --git a/_tutorials-FR/181_customizing_MEI/customizing-odd-04.html b/_tutorials-FR/181_customizing_MEI/customizing-odd-04.html
new file mode 100644
index 00000000..d17fd65d
--- /dev/null
+++ b/_tutorials-FR/181_customizing_MEI/customizing-odd-04.html
@@ -0,0 +1,104 @@
+
+
+ Vous avez déjà appris comment utiliser le
+ MEI ProfileDrafter, et vous avez utilisé le
+ Service de personnalisation MEI
+ pour compiler votre propre personnalisation. Vous avez téléchargé un fichier
+ .odd avec cette personnalisation. Nous supposons que votre
+ personnalisation exclut certains modules, éléments et classes d'attributs.
+ Examinons maintenant comment cela se manifeste dans le fichier de
+ personnalisation ODD. Veuillez l'ouvrir avec n'importe quel éditeur XML
+ pratique.
+
+
+ Vous trouverez un fichier TEI normal, avec quelques avertissements en haut,
+ et un élément <teiHeader> qui peut servir de point de
+ départ pour fournir une documentation appropriée pour votre
+ personnalisation. Vous voudrez certainement ajuster le
+ <respStmt> (déclaration de responsabilité) qui se trouve
+ généralement vers la ligne 27 pour revendiquer la responsabilité. Le contenu
+ intéressant commence à la ligne 54 (le numéro exact peut varier). Là, nous
+ avons l'élément
+ <schemaSpec>, qui commence notre personnalisation. Mettons de côté les attributs
+ spécifiés ici, et ignorons également l'élément
+ <constraintSpec> pour le moment.
+
+
+ Ce que nous voyons ensuite est une liste d'éléments
+ <moduleRef> (référence de module), chacun se référant à un module MEI avec son attribut @key.
+ Seuls les attributs que vous n'avez pas exclus du schéma sont répertoriés
+ ici. En conséquence, il est très simple d'exclure manuellement un module MEI
+ d'une personnalisation : vous devez simplement supprimer la référence à
+ celui-ci dans votre fichier de personnalisation.
+
+
+ Sur un ou plusieurs <moduleRef>, vous devriez voir un
+ attribut supplémentaire @except. Cet attribut contient une
+ liste d'éléments du module spécifié, qui doivent être
+ exclus de la personnalisation. Fondamentalement, ici, vous pouvez
+ prendre sélectivement des éléments individuels, tout en conservant tous les
+ autres du module actuel dans votre personnalisation. ODD prend également en
+ charge l'approche inverse permettant d'autoriser explicitement des éléments
+ d'un module grâce à l'attribut @include. Il n'est pas autorisé
+ de combiner les deux approches, et selon les directives TEI, les processeurs
+ ODD sont invités à émettre un message d'erreur. Le MEI ProfileDrafter
+ comprendra les deux approches lors de l'importation de personnalisations
+ existantes, mais préférera @except à @include lors de
+ l'exportation de données.
+
+
+ Enfin, à la fin de votre fichier ODD, il y aura une liste d'éléments
+ <classSpec> (spécification de classe) avec @type="atts". Ils utilisent également l'attribut
+ @ident pour identifier des classes d'attributs individuelles.
+ Veuillez noter que cet élément n'a aucune référence au module dans lequel
+ cet attribut est défini. Au lieu de cela, et plus important encore, il
+ utilise l'attribut @mode
+ pour spécifier ce qui doit être fait aux sources MEI originales, qui sont
+ censées être modifiées par votre personnalisation. Ici, la seule valeur
+ utilisée sera
+ @mode="delete" – les classes d'attributs correspondantes seront
+ supprimées de votre personnalisation, les rendant indisponibles dans le
+ schéma résultant. Encore une fois, il est très simple de faire de telles
+ exclusions manuellement.
+
+
+ Comme vous pouvez le constater, le MEI ProfileDrafter fait en réalité très
+ peu de choses dans ODD – c'est principalement une interface utilisateur
+ pratique qui aide à illustrer les conséquences de la suppression de divers
+ composants du schéma. Par exemple, il montre très clairement quels attributs
+ sur l'élément <note> seront indisponibles lorsque le
+ module MEI.gestural est désactivé. Techniquement, cependant, il ne
+ fait que des choses très simples que l'on pourrait mettre en œuvre
+ manuellement tout aussi bien.
+
+
+ À l'étape suivante, nous introduirons quelques concepts supplémentaires pour
+ les personnalisations ODD, ouvrant la voie à des personnalisations ODD
+ encore plus spécifiques.
+
+
diff --git a/_tutorials-FR/181_customizing_MEI/customizing-odd-05.html b/_tutorials-FR/181_customizing_MEI/customizing-odd-05.html
new file mode 100644
index 00000000..3e3a3a75
--- /dev/null
+++ b/_tutorials-FR/181_customizing_MEI/customizing-odd-05.html
@@ -0,0 +1,118 @@
+
+
+ À la dernière étape, nous avons appris qu'un
+ <classSpec type="atts" ident="att.basic" mode="delete"/>
+ peut être utilisé pour supprimer la classe d'attributs
+ att.basic (comme toute autre) d'une personnalisation MEI.
+ L'attribut @mode est ce qui détermine ce comportement ici. Les
+ directives TEI pour la classe d'attributs
+ att.combinable
+ fournissent une documentation supplémentaire sur les valeurs autorisées.
+ Elle indique que "un processeur ODD doit gérer les valeurs de @mode comme suit":
+
+
+
add
+
+ l'objet doit être créé (en traitant éventuellement les enfants en mode
+ add); générer une erreur si un objet avec le même identifiant existe déjà
+
+
replace
+
+ utiliser cet objet de préférence à tout objet existant avec le même
+ identifiant, et ignorer tout enfant de cet objet; traiter tout nouvel
+ enfant en mode 'replace'
+
+
delete
+
+ ne pas traiter cet objet ni aucun objet existant avec le même identifiant;
+ générer une erreur si de nouveaux enfants sont fournis
+
+
change
+
+ traiter cet objet, et traiter ses enfants, ainsi que ceux de tout objet
+ existant avec le même identifiant, en mode 'change'
+
+
+
+ Avec cela, il est possible non seulement de supprimer des classes
+ d'attributs via une personnalisation, mais aussi de les modifier. Par
+ exemple, dans la
+ personnalisation MEI de base, l'attribut @xml:base est supprimé du schéma. Dans les
+ sources MEI, cela est défini dans la classe d'attributs
+ att.basic :
+
+
+<classSpec ident="att.basic" module="MEI.shared" type="atts">
+ <desc>Attributs qui forment la base de la classe att.common.</desc>
+ <classes>
+ <memberOf key="att.id"/>
+ </classes>
+ <attList>
+ <attDef ident="xml:base" usage="opt">
+ <desc>Fournit une référence d'URI de base avec laquelle les applications peuvent résoudre des références d'URI relatives en références d'URI absolues.</desc>
+ <datatype>
+ <rng:ref name="data.URI"/>
+ </datatype>
+ </attDef>
+ </attList>
+</classSpec>
+
+ Comme vous pouvez le voir, la classe att.basic est membre de la
+ classe att.id - qui est responsable de rendre l'attribut
+ @xml:id disponible sur chaque élément. Ainsi, supprimer
+ att.basic du schéma interdirait également l'utilisation des
+ @xml:id n'importe où dans les fichiers conformes à la
+ personnalisation résultante - certainement pas une bonne idée dans tout cas
+ d'utilisation pratique. À la place, la flexibilité offerte par les
+ différents @modes peut être utilisée pour faire des
+ déclarations plus précises ici. L'exemple suivant montre ce qui a été fait
+ pour personnaliser att.basic pour le profil MEI de base :
+
+
+<classSpec ident="att.basic" module="MEI.shared" type="atts" mode="replace">
+ <desc>Attributs qui forment la base de la classe att.common.</desc>
+ <classes>
+ <memberOf key="att.id"/>
+ </classes>
+</classSpec>
+
+ Au lieu de mode="delete", il utilise
+ mode="replace" pour donner une nouvelle définition à la classe
+ d'attributs. Cette classe d'attributs manque alors de la définition
+ d'attribut pour @xml:base. Alternativement, il aurait été
+ possible d'utiliser @mode="change" sur la classe d'attributs,
+ omettre les classes enfants (comme une valeur de change déclenchera
+ le traitement des classes d'origine également, voir ci-dessus), et ajouter
+ un mode="delete" supplémentaire sur la définition de
+ l'attribut, comme on peut le voir dans l'exemple suivant :
+
+ Les deux approches donnent les mêmes résultats, donc c'est surtout une
+ question de préférence de choisir une solution. En général, il est judicieux
+ de copier une définition existante (qui est toujours accessible via les
+ directives MEI) dans votre personnalisation, puis de l'ajuster en insérant
+ soigneusement des @modes de traitement sur l'objet lui-même et
+ ses enfants. @mode peut être utilisé sur un certain
+
+
diff --git a/_tutorials-FR/181_customizing_MEI/customizing-odd-06.html b/_tutorials-FR/181_customizing_MEI/customizing-odd-06.html
new file mode 100644
index 00000000..d5cf0429
--- /dev/null
+++ b/_tutorials-FR/181_customizing_MEI/customizing-odd-06.html
@@ -0,0 +1,48 @@
+
+
+ Le MEI standard autorise les éléments du document suivants
+ : <mei>, <meiHead>,
+ <music>, et <meiCorpus>. Cela signifie
+ que ces éléments peuvent servir d'éléments extérieurs dans un fichier MEI.
+ Cependant, un projet peut concevoir une structure de données qui nécessite
+ d'autres éléments de départ ou des éléments de départ additionnels. Par
+ exemple, un projet peut décider de conserver toutes les annotations
+ éditoriales dans des fichiers séparés, chacun contenant son propre élément
+ <annot>. La personnalisation officielle
+ mei-all_anyStart
+ permet d'utiliser chaque élément individuel dans l'espace de noms MEI comme
+ élément de départ, mais cela est principalement à des fins pédagogiques et
+ n'est pas recommandé pour un usage pratique. À la place, ODD offre un
+ mécanisme simple pour définir les éléments de départ autorisés, en utilisant
+ l'élément initial <schemaSpec>.
+
+ Comme vous pouvez le voir, l'attribut @start est utilisé comme
+ une liste séparée par des espaces de tous les éléments de départ. Si le
+ projet mentionné ci-dessus décidait d'autoriser <mei> et
+ <annot>, mais de désautoriser tous les autres éléments de
+ départ, cela pourrait être modifié comme suit :
+
+ Comme vous pouvez le constater, ajuster les éléments de départ est en
+ réalité assez simple. Résumons ce que nous avons appris sur la
+ personnalisation ODD.
+
+
diff --git a/_tutorials-FR/181_customizing_MEI/customizing-odd-end.html b/_tutorials-FR/181_customizing_MEI/customizing-odd-end.html
new file mode 100644
index 00000000..3625bd91
--- /dev/null
+++ b/_tutorials-FR/181_customizing_MEI/customizing-odd-end.html
@@ -0,0 +1,53 @@
+
+
+ Vous avez appris à utiliser le
+ MEI ProfileDrafter
+ pour créer des personnalisations MEI à travers une interface utilisateur
+ graphique. Vous avez appris que cet outil a une portée limitée, mais permet
+ déjà de restreindre considérablement MEI. Vous avez appris que le balisage
+ ODD généré par l'outil est en réalité assez simple et peut être réalisé
+ manuellement tout aussi bien. Vous avez appris à utiliser les
+ @modes dans les personnalisations avancées de l'ODD, et comment ils permettent
+ un contrôle plus précis sur le schéma résultant. En cours de route, vous
+ avez également appris comment compiler une personnalisation ODD en un
+ fichier RelaxNG pouvant être utilisé pour la validation, en utilisant le
+ service de personnalisation MEI.
+
+
+ Bien sûr, il existe d'autres moyens de compiler l'ODD, d'autres concepts à
+ prendre en compte, et le fait que MEI utilise une version plus ancienne de
+ l'ODD que la TEI (comme décrit dans le tutoriel
+ Comprendre l'ODD) peut causer de la confusion en cours de route. Travailler avec l'ODD est
+ certainement un peu étrange, mais cela vaut vraiment la peine, car cela vous
+ permet d'utiliser une version de MEI très spécifique à vos besoins. Cela
+ vous aidera à fournir une documentation appropriée, ce qui permettra aux
+ autres de mieux comprendre et utiliser vos données. Ainsi, écrire des
+ personnalisations ODD est certainement un bon investissement pour la
+ durabilité de votre recherche.
+
+
+ Un avertissement : Ce tutoriel est encore largement en cours d'élaboration
+ et peut être organisé différemment après avoir recueilli des commentaires
+ lors de plusieurs ateliers.
+
+
diff --git a/_tutorials-FR/181_customizing_MEI/customizing-odd.json b/_tutorials-FR/181_customizing_MEI/customizing-odd.json
new file mode 100644
index 00000000..c0082dfc
--- /dev/null
+++ b/_tutorials-FR/181_customizing_MEI/customizing-odd.json
@@ -0,0 +1,35 @@
+{
+ "steps": [
+ {
+ "label":"Bienvenue",
+ "descFile": "customizing-odd-01.html"
+ },
+ {
+ "label":"Conception de profils",
+ "descFile": "customizing-odd-02.html"
+ },
+ {
+ "label":"Compilation de l'ODD",
+ "descFile": "customizing-odd-03.html"
+ },
+ {
+ "label":"Quelques configurations simples",
+ "descFile": "customizing-odd-04.html"
+ },
+ {
+ "label":"Comprendre les modes",
+ "descFile": "customizing-odd-05.html"
+ },
+ {
+ "label":"Modifier les racines",
+ "descFile": "customizing-odd-06.html"
+ }
+ ],
+ "end":"customizing-odd-end.html",
+ "resp":[
+ {
+ "name":"Johannes Kepper",
+ "affiliation":"Beethovens Werkstatt | Universität Paderborn"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/_tutorials-FR/181_customizing_MEI/customizing-odd.md b/_tutorials-FR/181_customizing_MEI/customizing-odd.md
new file mode 100644
index 00000000..f41070ef
--- /dev/null
+++ b/_tutorials-FR/181_customizing_MEI/customizing-odd.md
@@ -0,0 +1,7 @@
+---
+layout: tutorials-FR
+type: tutorial-FR
+name: "AVANCÉ : Configurer la MEI (WIP)"
+fullname: "Création de profils MEI personnalisés"
+data: "customizing-odd.json"
+---
diff --git a/_tutorials-FR/199_tutorials/just-a-name.xml b/_tutorials-FR/199_tutorials/just-a-name.xml
new file mode 100644
index 00000000..be8152b8
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/just-a-name.xml
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
diff --git a/_tutorials-FR/199_tutorials/tutorials.json b/_tutorials-FR/199_tutorials/tutorials.json
new file mode 100644
index 00000000..1593fb31
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/tutorials.json
@@ -0,0 +1,31 @@
+{
+ "steps": [
+ {
+ "label":"Bienvenue",
+ "descFile": "writingTutorials-01.html"
+ },
+ {
+ "label":"Configuration du site web",
+ "descFile": "writingTutorials-02.html"
+ },
+ {
+ "label":"Le fichier JSON",
+ "descFile": "writingTutorials-03.html"
+ },
+ {
+ "label":"L'éditeur",
+ "descFile": "writingTutorials-04.html"
+ },
+ {
+ "label":"Validation",
+ "descFile": "writingTutorials-05.html"
+ }
+ ],
+ "end":"writingTutorials-06.html",
+ "resp":[
+ {
+ "name":"Johannes Kepper",
+ "affiliation":"Beethovens Werkstatt | Universität Paderborn"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/_tutorials-FR/199_tutorials/tutorials.md b/_tutorials-FR/199_tutorials/tutorials.md
new file mode 100644
index 00000000..5f1591cd
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/tutorials.md
@@ -0,0 +1,7 @@
+---
+layout: tutorials-FR
+type: tutorial-FR
+name: "META : Écrire des tutoriels"
+fullname: "Une introduction à l'écriture des tutoriels sur la MEI"
+data: "tutorials.json"
+---
diff --git a/_tutorials-FR/199_tutorials/tutorials.xml b/_tutorials-FR/199_tutorials/tutorials.xml
new file mode 100644
index 00000000..811c8cdb
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/tutorials.xml
@@ -0,0 +1,34 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/_tutorials-FR/199_tutorials/writingTutorials-01.html b/_tutorials-FR/199_tutorials/writingTutorials-01.html
new file mode 100644
index 00000000..c9737007
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/writingTutorials-01.html
@@ -0,0 +1,34 @@
+
+
Un tutoriel tout particulier...
+
+ Manifestement, vous vous intéressez à la MEI, et c'est merveilleux ! Une
+ bonne façon de vous assurer de bien comprendre ce format pourrait être de
+ rédiger un tutoriel à ce sujet, ce qui, par là même, aidera les autres à
+ mieux comprendre.
+
+
+ Rédiger de la documentation est généralement une tâche ingrate. Peu importe
+ la quantité que vous écrivez, il y a toujours besoin de plus, et quoi que
+ vous fassiez, vous ne pourrez jamais répondre aux besoins et aux attentes de
+ tout le monde. Nous pensons que la meilleure façon de résoudre ce problème
+ est de répartir la tâche sur de nombreuses épaules, en réduisant la charge
+ de travail de chacun. En plus, en approchant la MEI sous différents angles
+ et niveaux d'expertise, il devient plus facile d'apporter une aide précise à
+ chacun.
+
+
+ Donc, lorsque vous avez appris quelque chose sur la MEI et que vous pensez
+ que d'autres pourraient en bénéficier, s'il vous plaît,
+ n'hésitez pas à contribuer. Ce tutoriel vous expliquera ce qui est
+ nécessaire. Pas de souci, vous n'avez pas besoin d'être un programmeur pour
+ écrire votre propre tutoriel, une introduction à un répertoire spécifique ou
+ des recommandations de bonnes pratiques générales. La communauté MEI est là
+ pour vous
+ aider, et
+ l'équipe
+ Technique
+ veillera à ce que tout ce que vous écrivez soit techniquement correct - rien
+ ne peut mal tourner, promis. Alors suivez-nous à la page suivante en
+ cliquant sur continuer ci-dessous.
+
+
diff --git a/_tutorials-FR/199_tutorials/writingTutorials-02.html b/_tutorials-FR/199_tutorials/writingTutorials-02.html
new file mode 100644
index 00000000..309005ed
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/writingTutorials-02.html
@@ -0,0 +1,60 @@
+
+
+ Comme le reste de notre site web, tous les tutoriels sont directement
+ publiés à partir d'un
+ dépôt GitHub. Cela offre à la fois des avantages et des inconvénients. Un énorme
+ avantage est que la création d'un nouveau tutoriel est aussi simple que de
+ commit un dossier dans le dépôt (nous expliquerons cela plus tard, pas
+ d'inquiétude). Les inconvénients majeurs sont que l'interaction requise pour
+ un tutoriel n'est pas très bien prise en charge par cette configuration
+ technique, et que nous ne pouvons pas systématiquement valider
+ automatiquement le schéma MEI fourni par l'utilisateur. Ces deux aspects ont
+ été pris en compte, et nous espérons que nos solutions équilibrent le besoin
+ d'orientation de l'utilisateur et l'effort nécessaire
+ pour préparer un tutoriel. Nous y reviendrons plus tard également.
+
+
+ Maintenant, commençons. Nos pages sont construites et générées par
+ Jekyll. Pour nos
+ tutoriels, cela signifie que nous avons besoin d'un fichier
+ Markdown
+ avec les détails sur notre tutoriel que le site web environnant doit
+ connaître pour l'intégrer correctement. Jetons un coup d'œil au fichier
+ Markdown de ce tutoriel :
+
+
+---
+---
+layout: tutorials-FR
+type: tutorial-FR
+name: "Écrire des tutoriels"
+fullname: "Une introduction à l'écriture des tutoriels sur la MEI"
+data: "tutorials.json"
+---
+
+
+ Alors que les deux premières lignes, layout: tutorials-FR et
+ type: tutorial-FR doivent toujours rester de cette manière pour
+ les tutoriels en français, les deux lignes suivantes peuvent changer. Ce que
+ vous écrivez ici est affiché dans la liste des tutoriels, par exemple. Notez
+ que la toute première et la dernière ligne, chacune contenant trois tirets,
+ doivent rester de cette manière pour que le tutoriel fonctionne
+ correctement.
+
+
+ Comme cela a été mentionné précédemment, nous devons travailler dans une
+ certaine mesure autour des limitations de notre configuration technique.
+ Pour cette raison, nous faisons référence à un fichier appelé
+ tutorials.json, qui se trouve dans le même dossier. Le nom du
+ fichier n'a pas d'importance, tant qu'il peut être trouvé dans le même
+ dossier que le fichier Markdown. Passons maintenant au contenu de ce fichier
+ JSON.
+
+
diff --git a/_tutorials-FR/199_tutorials/writingTutorials-03.html b/_tutorials-FR/199_tutorials/writingTutorials-03.html
new file mode 100644
index 00000000..c253067c
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/writingTutorials-03.html
@@ -0,0 +1,128 @@
+
+
+ Le fichier
+ JSON
+ représente la table des matières du tutoriel. Il contient un objet avec
+ plusieurs propriétés. Jetons un coup d'œil à (une version simplifiée) du
+ tutoriel actuel :
+
+ Il y a trois propriétés importantes ici. La première, "steps",
+ est utilisée pour décrire les différentes étapes d'un tutoriel. Nous y
+ reviendrons dans un instant. Ensuite, "end" spécifie un fichier
+ dans lequel la page finale du tutoriel est fournie. Enfin, il y a
+ "resp". Dans cet ensemble, vous devez indiquer votre nom et
+ votre affiliation. Cela permet d'identifier l'auteur et d'être en mesure de
+ le contacter pour des questions, mais aussi de vous donner une
+ reconnaissance publique pour le travail que vous faites sur la MEI. Si vous
+ avez travaillé sur un tutoriel avec un groupe de personnes, vous pouvez bien
+ sûr toutes les inclure. Alors pourquoi ne pas demander à certains de vos
+ étudiants de travailler sur ces tutoriels ?
+
+
Étapes
+
+ Revenons à la propriété "steps". Il s'agit d'un tableau d'objets,
+ décrivant chacun une étape du tutoriel. La seule propriété qui est
+ obligatoire est "descFile". Ici, vous devez fournir le nom du
+ fichier HTML qui correspond au contenu de cette étape. Par exemple le texte que vous
+ lisez actuellement provient de l'un de ces fichiers. Ce fichier n'est pas un
+ fichier HTML complet ; il doit commencer par un élément racine
+ <div> et contenir du HTML simple. La propriété suivante,
+ "label", est facultative. Si vous ne la fournissez pas, l'étape
+ sera étiquetée en fonction de sa position (c'est-à-dire "Étape 3" ou
+ similaire).
+
+
+ Évidemment, un tutoriel n'est pas censé être uniquement du texte (cela ne
+ justifierait guère toute cette configuration...). Parfois, vous voudrez
+ peut-être que l'utilisateur encode réellement des éléments MEI. Regardons la
+ définition d'une telle étape :
+
+ Les deux propriétés que nous connaissons déjà sont en gris, nous n'avons pas
+ besoin d'y revenir. Si une étape contient à la fois une propriété
+ "xmlFile" et une propriété "xpaths", un éditeur
+ sera affiché. En même temps, le bouton "Continuer" en bas à droite
+ disparaîtra. Pour avancer, l'utilisateur doit maintenant suivre vos
+ instructions et entrer le code MEI dans l'éditeur. Pour décider si
+ l'utilisateur a réussi ou non, vous devez fournir un certain nombre de
+ règles
+ XPath.
+ L'expression XPath elle-même est stockée dans une propriété
+ "rule". Elle doit renvoyer une valeur booléenne, c'est-à-dire
+ true ou false. Si vous souhaitez guider l'utilisateur, vous
+ pouvez fournir une propriété "hint". Si le contenu de l'éditeur
+ ne correspond pas à une règle XPath, son indication sera affichée comme une
+ boîte d'avertissement en dessous de l'éditeur. Les règles XPath sont
+ vérifiées dans l'ordre, et la vérification s'arrête dès qu'une règle est
+ fausse. Si toutes les règles sont satisfaites, le tutoriel passera
+ automatiquement à l'étape suivante.
+
+
+ La propriété "renderanyway" d'une règle XPath est utile lorsque
+ vous souhaitez que l'utilisateur manipule l'encodage. Normalement, la
+ saisie de l'utilisateur n'est rendue que lorsque toutes les règles XPath
+ sont satisfaites. Cependant, vous pourriez demander à l'utilisateur
+ d'essayer différentes hauteurs, en indiquant que le tour continue lorsqu'une
+ hauteur spécifique est entrée. Ensuite, vous pouvez définir
+ "renderanyway" sur true, et Verovio fera de son
+ mieux pour rendre la saisie actuelle de l'utilisateur. Ce comportement est
+ implémenté dans la deuxième règle XPath ci-dessus.
+
+
+ La propriété "xmlfile" spécifie un fichier qui sert de contexte
+ pour l'éditeur. Dans la prochaine étape de ce tutoriel, nous expliquerons
+ cela en détail. Il existe deux autres propriétés qui peuvent être utiles.
+ Avec la propriété "editorLines", vous pouvez spécifier la
+ hauteur de la fenêtre de l'éditeur. Si vous ne rentrez rien, une hauteur par défaut de 5 lignes
+ sera appliquée. Enfin, vous pouvez préremplir l'éditeur au début d'une étape
+ avec le contenu d'un fichier que vous spécifiez avec la propriété "prefillFile".
+ Si vous n'en spécifiez pas, l'éditeur conserve le code entré par l'utilisateur durant
+ l'étape précédante (ou il est vide s'il s'agit de la première étape.)
+
+
diff --git a/_tutorials-FR/199_tutorials/writingTutorials-04.html b/_tutorials-FR/199_tutorials/writingTutorials-04.html
new file mode 100644
index 00000000..0359846a
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/writingTutorials-04.html
@@ -0,0 +1,68 @@
+
+
+ Lorsque vous réalisez un tutoriel par vous-même, vous vous êtes peut-être
+ demandé comment Verovio parvient à rendre le code MEI de l'utilisateur, même si
+ l'utilisateur n'entre pas un fichier MEI complet. Cela est permis grâce à la
+ propriété "xmlFile" introduite à la dernière page. Cette
+ propriété fait référence à un fichier MEI complet, qui fournit le contexte
+ nécessaire pour encadrer la saisie de l'utilisateur en vue d'un rendu
+ correct. Regardons un exemple simple :
+
+ Il s'agit simplement d'un fichier MEI classique, mais qui contient deux
+ instructions de traitement importantes (marquées en rouge). Le
+ contenu de ce fichier est lu en mémoire. Chaque fois que la saisie de
+ l'utilisateur dans l'éditeur est bien formée en XML, elle est insérée
+ entre les deux instructions de traitement, et le fichier complet
+ (incluant désormais la saisie de l'utilisateur) est validé et (le cas
+ échéant) envoyé à Verovio pour le rendu.
+
+
+ Ce qui est stocké entre les deux instructions de traitement est
+ destiné à servir de solution d'exemple. Cette fonctionnalité n'est pas
+ encore implémentée, mais le sera bientôt. Il est déjà possible de
+ télécharger le fichier complet (incluant le contexte), de sorte que les
+ utilisateurs puissent les utiliser comme référence future ou comme modèle
+ pour leur propre travail.
+
+
diff --git a/_tutorials-FR/199_tutorials/writingTutorials-05.html b/_tutorials-FR/199_tutorials/writingTutorials-05.html
new file mode 100644
index 00000000..256e9c58
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/writingTutorials-05.html
@@ -0,0 +1,51 @@
+
+
+ Cela va sans dire, la validation correcte de la saisie est importante pour
+ un apprentissage efficace et durable. Cependant, parce que notre site web
+ est basé sur Jekyll, nous devons compter sur la validation côté client (se
+ fier uniquement à un service externe pour la validation n'est probablement
+ pas fiable, c'est pourquoi nous avons opté pour cette approche). À ce jour,
+ la validation côté client (c'est-à-dire, en utilisant JavaScript) ne prend
+ pas en charge correctement le
+ RelaxNG,
+ le langage de schéma utilisé en bout de chaine pour valider les instances
+ MEI dans de vrais projets. Pour cette raison, nous devons utiliser
+ l'approche basée sur XPath mentionnée précédemment.
+
+
+ La propriété "xpaths" de l'étape actuelle contient un tableau
+ de règles auxquelles la saisie de l'utilisateur doit se conformer pour
+ accomplir cette étape. Ces règles sont spécifiées sous la forme d'objets
+ JSON avec trois propriétés :
+
+
+{
+ "rule":"//mei:note/@pname = 'g'",
+ "renderanyway":true,
+ "hint":"Vous avez besoin d'un attribut @pname, avec une valeur de g."
+}
+
+ La propriété "rule" contient une expression
+ XPath 1,
+ qui doit se résoudre en une déclaration booléenne : elle doit être soit
+ true soit false. La propriété "renderanyway" est
+ utilisée pour décider si l'éditeur actuel peut être rendu par Verovio même
+ si le XPath n'est pas respecté. Le contenu de la propriété
+ "hint" est censé aider l'utilisateur à réussir son encodage.
+ Seule la première règle XPath qui échoue est affichée, guidant l'utilisateur
+ pas à pas à travers les différentes erreurs. Cependant, toutes les étapes
+ n'ont pas besoin d'une aide – parfois, il est préférable de laisser
+ l'utilisateur explorer un peu par lui-même.
+
+
+ Pour la validation, la saisie de l'utilisateur sera insérée entre les
+ marqueurs <?snippet-start?> et
+ <?snippet-end?> dans le fichier XML actuel, puis les
+ règles XPath seront vérifiées par rapport à ce fichier complet. Dès qu'une
+ de ces règles échoue (c'est-à-dire, renvoie false), l'astuce
+ correspondante sera affichée. Lorsque toutes les règles renvoient
+ true, le bouton "continuer" sera activé et l'utilisateur pourra
+ passer à l'étape suivante.
+
+
diff --git a/_tutorials-FR/199_tutorials/writingTutorials-06.html b/_tutorials-FR/199_tutorials/writingTutorials-06.html
new file mode 100644
index 00000000..98072798
--- /dev/null
+++ b/_tutorials-FR/199_tutorials/writingTutorials-06.html
@@ -0,0 +1,28 @@
+
+
+ Et voilà ! À présent vous avez simplement besoin d'écrire un ensemble de
+ fichiers et de les soumettre sur le dépôt GitHub du site MEI, dans le
+ dossier des tutoriels. Idéalement, vous pouvez préparer le tutoriel sur votre propre fork du
+ projet, puis vous envoyez une demande de fusion (pull request) vers le dépot
+ principal et demanderez des avis aux membres de l'équipe technique. Bien
+ sûr, nous sommes heureux de vous aider – il vous suffit de
+ nous contacter. Pour vous lancer rapidement, vous pouvez copier un tutoriel existant et
+ le modifier selon vos besoins. Le tutoriel
+ 101_quickstart devrait être un bon point de départ, car il est
+ très simple, mais contient toutes les fonctionnalités pertinentes.
+
+
+ Merci de votre lecture. Votre contribution pourra certainement faire la
+ différence. Même si vous n'êtes pas sûr d'être suffisamment familier avec
+ MEI, vous pouvez certainement partager certaines de vos idées avec d'autres.
+ Même si vous avez simplement une idée de ce qui devrait être abordé par un
+ tutoriel, n'hésitez pas à vous manifester, afin que nous puissions peut-être
+ construire cela ensemble – en tant que communauté, pour la communauté.
+
+
diff --git a/js/mei-tutorials.js b/js/mei-tutorials.js
index 0b664d5a..48e4dc2c 100644
--- a/js/mei-tutorials.js
+++ b/js/mei-tutorials.js
@@ -66,6 +66,15 @@ var tutorialStrings = {
'networkError': 'La respuesta de la red no fue correcta al intentar buscar:',
'renderingError': 'La codificación actual no se puede representar.',
'showHint': 'mostrar pista',
+ },
+ 'FR': {
+ 'codeNotWellformed': 'Le code n\'est pas correctement formaté.',
+ 'fetchOperationProblem': 'Il y a eu un problème lors de la réccupération des données pour :',
+ 'finish': 'Terminer',
+ 'hideHint': 'masquer l\'indice',
+ 'networkError': 'La réponse côté serveur est incorrecte :',
+ 'renderingError': 'L\'encodage fourni ne peut pas être rendu correctement.',
+ 'showHint': 'afficher l\'indice',
}
};
diff --git a/resources/tutorials-FR.md b/resources/tutorials-FR.md
new file mode 100644
index 00000000..ceb962fd
--- /dev/null
+++ b/resources/tutorials-FR.md
@@ -0,0 +1,22 @@
+---
+layout: tutorials-FR
+title: "Tutoriels MEI"
+---
+
+# Tutoriels sur le MEI
+
+Sur cette page, vous trouverez une série de courts tutoriels pour aborder la MEI, chacun d'entre eux présente une fonctionnalité spécifique de cette spécification.
+
+Si vous débuttez avec la MEI, nous vous recommandons de commencer par le tutoriel [Quickstart](/tutorials-FR/101-quickstart), qui vous permettra de coder une mélodie simple avec le MEI.
+
+Si vous souhaitez rédiger un nouveau tutoriel sur la MEI, nous vous recommandons de commencer par le tutoriel [Rédaction de tutoriels](/tutorials-FR/tutorials), qui vous fournira des informations sur les étapes nécessaires. Consultez également notre liste de tutoriels manquants sur [Github] (https://github.com/music-encoding/music-encoding.github.io/issues/88) avec lesquels vous pourriez contribuer au projet.
+
+### Autres tutoriels et ressources liées
+
+Pour d'autres ressources créées par la communauté, y compris les tutoriels et des ressources pédagogiques, voir [Ressources pédagogiques et pratiques créées par la communauté](/resources/pedagogy.html).
+
+Retour aux [tutoriels en anglais](/resources/tutorials.html).
+
+---
+
+_Traductions réalisées par Aurelien Balland Chatignon et Félix Poullet-Pagès pour la Music Encoding Initiative, ingénieurs d'études à [l'Institut de recherche en musicologie](http://iremus.cnrs.fr) et membres du consortium [MUSICA2](https://musica.hypotheses.org)_
diff --git a/resources/tutorials.md b/resources/tutorials.md
index 3c402012..ff438e03 100644
--- a/resources/tutorials.md
+++ b/resources/tutorials.md
@@ -15,4 +15,6 @@ If you're about to write a new MEI tutorial, we recommend to start with the [Wri
For community-created resources including tutorials and teaching material, see [Community-Created Pedagogy & Praxis Resources](/resources/pedagogy.html).
-For a Spanish translation of the tutorials, see [Tutoriales en español](/resources/tutorials-ES.html).
\ No newline at end of file
+For a Spanish translation of the tutorials, see [Tutoriales en español](/resources/tutorials-ES.html).
+
+For a French translation of the tutorials, see [Tutoriels en français](/resources/tutorials-FR.html).
\ No newline at end of file