//---------------------------------------------------------------------
// DiatonicTab, MuseScore 3 plugin
//---------------------------------------------------------------------
//=============================================================================
// MuseScore
// Music Composition & Notation
//
// Create Tablature for diatonic accordion from a MuseScore music score
//
// Copyright (C) 2020 Jean-Michel Bencetti
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation and appearing in
// the file LICENCE.GPL
//
//=============================================================================
//--------------------------------------------------------------------------
/* Ce plugin ajoute le numéro des touches pour accordéon diatonique
afin de créer une forme très simplifiée de tablature
Ce plugin utlise le textes de paroles pour mettre les numéros de touches
afin de pouvoir aligner verticalement différement les tirés et les poussés
Auteur : Jean-Michel Bencetti
Version courrante : 1.04
Date : v1.00 : 2019-06-13 : développement initial
v1.02 : 2019-09-02 : tient compte des accords main gauche pour proposer les notes en tiré ou en poussé
v1.03 : 2019-10-11 : ajoute la possibilité de ne traiter que des mesures sélectionnées
v1.04 : 2020-02-24 : propose une fenêtre de dialogue pour utiliser différents critères
v1.05 : 2020-03-02 : gestion de plans de claviers différents
mémorisation des parametres dans un fichier format json
préparation à la traduction du plugin
v1.05.04 : 20200316: ajouts de claviers et corrections de quelques dysfonctionnements
Description version v1.02 :
Pour les accords main gauche A, Am, D, Dm, seules les touches en tirées sont proposées
Pour les accords main gauche E, Em, E7, C, seules les touches en poussé sont proposées
Pour les accords main gauche G et F, les deux numéros de touches sont proposées lorsqu'elles existes
Les notes altérées (sauf F#) ne sont pas proposées car trop de plan de claviers différents existent
Pour la note G, les deux propositions sont faites sur le premier et deuxième rang
Après le passage du plugin, il reste donc à faire le ménage pour supprimer les numéros de touches en trop
pour les accords F et G et sur les notes G main droite
Description version v1.03 :
- pour limiter le travail du plugin, il est possible de sélectionner les mesures à traiter.
- sans sélection, le plugin travaille sur toute la partition sauf la dernière portée.
- la dernière portée n'est pas traitée car elle est sencée être en clé de Fa avec des Basses et des Accords.
- pour traiter quand même la dernière portée, il suffit de la sélectionner.
Description version v1.04 :
- propose une tablature sur une ou deux lignes
- propose de n'afficher qu'une seule alternative lorsque des notes existent sous plusieurs touches
- propose de tirer ou de pousser les G et les F ou d'indiquer les deux possibilités
- propose de privilégier le rang de G ou celui de C ou de favoriser le jeu en croisé
- propose un clavier 2 rangs ou 3 rangs (plan castagnari)
- utiliser les accords A B Bb C D E f G G# pour déterminer le sens
Description version v1.05
- Modification de la structure des plans de clavier main droite et main gauche pour admettre plusieurs type d'accordéons
- Adaptation du formulaire de choix en conséquence
- Adaptation du code pour prendre en compte les nouvelles structures
- Mémorisation des parametres dans un fichier DiatonicTab.json
- Ajouts plans de claviers
- Traduction en anglais
- Traitement des accords enrichis
- Nettoyage du code
- Tablatures CACB, Corgeron et DES (Rémi Sallard)
----------------------------------------------------------------------------*/
import QtQuick 2.2
import MuseScore 3.0
import QtQuick.Controls 1.1
import QtQuick.Controls.Styles 1.3
import QtQuick.Layouts 1.1
import FileIO 3.0
MuseScore {
//-----------------------------------------------------
// Set here the language : FR = French, other = English
property string lang: "FR"
//-----------------------------------------------------
// description: qsTr("Tablatures pour accordéon diatonique")
description: qsTr("Tablatures for diatonic accordion")
menuPath: "Plugins.DiatonicTab.Tablature"
requiresScore: true
version: "1.05.05"
pluginType: "dialog"
property int margin: 10
width: 480
height: 600
// Fichiers JSON pour la mémorisation des parametres
FileIO {
id: myParameterFile
source: homePath() + "/DiatonicTab.json"
onError: console.log(msg)
}
FileIO {
id: myKeyboardsFile
source: homePath() + "/DiatonicTabKeyboards.json"
onError: console.log(msg)
}
//---------------------------------------------------------------
// Variables de fonctionnement
//---------------------------------------------------------------
//-----------------------------------------------------------------
// Tableau des plans de clavier main gauche avec sens tiré ou poussé
//-----------------------------------------------------------------
property var tabClavierMainGauche:
// Clavier 8 basses Sol/Do
{ "GC8B" :
{
"description" : qsTr("G/C 8 Bass"),
"Pousse": "-C-E-B#-" ,
"Tire" : "-A-D-",
"2sens" : "-F-G-E#-" ,
},
// Clavier 8 basses Sol/Do NMAD
"GC8BNMAD" :
{
"description" : qsTr("G/C 8 Bass NMAD"),
"Pousse": "-C-E-B#-B-" ,
"Tire" : "-A-D-F-",
"2sens" : "-G-" ,
},
// Clavier Sol/Do 12 basses
"GC12B" :
{
"description" : qsTr("G/C 12 Bass"),
"Pousse": "-C-E-G#-D#-B#-" ,
"Tire" : "-A-D-B-A#-F#-C#-",
"2sens" : "-F-G-E#-",
},
// Clavier Sol/Do 18 basses
"GC18B" :
{
"description" : qsTr("G/C 18 Bass"),
"Pousse": "-C-E-G#-D#-B#-" ,
"Tire" : "-A-D-A#-F#-C#-",
"2sens" : "-F-G-B-E#-",
},
// Clavier 8 basses La/Ré
"AD8B" :
{
"description": qsTr("A/D 8 Bass"),
"Titre" : qsTr("A/D 8 Bass"),
"Pousse": "-D-F#-Gb-A#-Bb-",
"Tire" : "-B-E-",
"2sens" : "-G-A-",
},
"GC12BNAMD": // Sol/Do 12/18 basses N.A.M.D. 2018
{
"description" : qsTr("G/C 12/18 Bass NMAD"),
"Pousse": "-C-G#-E-D#-" ,
"Tire" : "-D-F-A-A#-",
"2sens" : "-G-B-" ,
},
// Irish diatonic
"C#D8B" :
{
"description" : qsTr("C#/D 8 Bass"),
"Pousse": "-D-F#-",
"Tire" : "-B-G-" ,
"2sens" : "-A-E-" ,
},
// BC
"BC8B" :
{
"description" : qsTr("B/C 8 Bass"),
"Pousse": "-E-C-B#-",
"Tire" : "-A-F-E#-",
"2sens" : "-D-G-",
},
// Sol/Do/Fa Marc Perrone
"GCF18BMP":
{
"description": qsTr("G/C/F 18 Bass Marc Peronne"),
"Pousse": "-F-E-C#-G#-",
"Tire" : "-D#-F#-B-",
"2sens" : "-C-D-G-A-A#-",
}
}
//--------------------------------------------------------------------------------------------
// Numéro des touches à appuyer. Si plusieurs boutons possible, il y a un / entre les numéros
// P pour Poussé, T pour Tiré
// Nom des notes : "C3" à "B3": du Do 2ème interligne clé de fa au si au dessus dernière ligne cla de fa
// "C4" à "B4": du do en bas de la clé de sol au si 3ième ligne clé de sol
// "C5" à "B5": du do 4ième interligne clé de sol au si 2 interlignes au dessus clé de sol
// "C6" à "B6": notes du dessus
//--------------------------------------------------------------------------------------------
property var planClavier:
{
// Sol/Do, Standard (sans altération touches 1 et 1'), 2 rangs, 21 boutons
"GCStd2R21" : {
description: "G/C 2 rangs, pas d'altération",
"C3" : "" ,"C3#" : "" ,"D3" : "2P" ,"D3#" : "" ,"E3" : "1'P" ,"F3" : "1'T",
"F3#": "2T" ,"G3" : "3P/2'P" ,"G3#" : "" ,"A3" : "3T" ,"A3#" : "" ,"B3" : "4P/2'T",
"C4" : "3'P/4T","C4#" : "" ,"D4" : "5P/3'T","D4#" : "" ,"E4" : "4'P/5T","F4" : "4'T",
"F4#" : "6T" ,"G4" : "6P/5'P" ,"G4#" : "" ,"A4" : "7T/5'T" ,"A4#" : "" ,"B4" : "7P/6'T",
"C5" : "6'P/8T","C5#" : "" ,"D5" : "8P/7'T","D5#" : "" ,"E5" : "7'P/9T","F5" : "8'T",
"F5#" : "10T" ,"G5" : "8'P/9P" ,"G5#" : "" ,"A5" : "9'T/11T","A5#" : "" ,"B5" : "10P/10'T",
"C6" : "9'P" ,"C6#" : "" ,"D6" : "11P" ,"D6#" : "" ,"E6" : "10'P" ,
},
// Sol/Do, Alt (avec altération touches 1 et 1'), 2 rangs 21 boutons
"GCAlt2R21" : {
description: "G/C 2 rangs, avec altérations",
"C3" : "" ,"C3#" : "" ,"D3" : "2P" ,"D3#" : "" ,"E3" : "" ,"F3" : "",
"F3#": "2T" ,"G3" : "3P/2'P" ,"G3#": "2''P" ,"A3" : "3T" ,"A3#": "1''T" ,"B3" : "4P/2'T",
"C4" : "3'P/4T","C4#" : "2''T" ,"D4" : "5P/3'T","D4#" : "2''P" ,"E4" : "4'P/5T","F4" : "4'T",
"F4#": "6T" ,"G4" : "6P/5'P" ,"G4#": "1''P" ,"A4" : "7T/5'T" ,"A4#": "1''T" ,"B4" : "7P/6'T",
"C5" : "6'P/8T","C5#" : "1T" ,"D5" : "8P/7'T","D5#" : "1P" ,"E5" : "7'P/9T","F5" : "8'T",
"F5#": "10T" ,"G5" : "8'P/9P" ,"G5#": "" ,"A5" : "9'T/11T","A5#": "" ,"B5" : "10P/10'T",
"C6" : "9'P" ,"C6#" : "" ,"D6" : "11P" ,"D6#" : "" ,"E6" : "10'P" ,
},
// Sol/Do, 2 rangs NMAD
"GCNAMD2R" : {
description: "G/C 2 rangs N.A.M.D. 2018",
"B2" : "1P" ,
"C3" : "" ,"C3#": "" ,"D3" : "2P" ,"D3#": "" ,"E3" : "1'P/1T","F3" : "1'T",
"F3#": "2T" ,"G3" : "3P/" ,"G3#": "" ,"A3" : "3T/2'P" ,"A3#": "" ,"B3" : "4P/2'T",
"C4" : "3'P/4T" ,"C4#": "" ,"D4" : "5P/3'T" ,"D4#": "" ,"E4" : "4'P/5T","F4" : "3''P/4'T",
"F4#": "6T" ,"G4" : "6P/5'T","G4#": "T" ,"A4" : "5'P/7T" ,"A4#": "" ,"B4" : "7P/6'T",
"C5" : "6'P/8T" ,"C5#": "" ,"D5" : "8P/7'T" ,"D5#": "" ,"E5" : "7'P/9T","F5" : "8'T",
"F5#": "10T" ,"G5" : "9P/9'T","G5#": "" ,"A5" : "8'P/11T","A5#": "" ,"B5" : "10P/10'T",
"C6" : "9'P/12T","C6#": "" ,"D6" : "11P" ,"D6#": "" ,"E6" : "10'P" ,"F6" : "",
"F#6" : "" ,"G6" : "" ,"G6#": "" ,"A6" : "" ,
},
// Sol/Do, 3 rangs NMAD
"GCNMAD3R" : {
description: "G/C 3 rangs N.A.M.D. 2018",
"B2" : "1P" ,
"C3" : "" ,"C3#": "" ,"D3" : "2P" ,"D3#": "" ,"E3" : "1'P/1T","F3" : "1'T",
"F3#": "2T" ,"G3" : "3P/","G3#": " 2''P","A3" : "3T/2'P" ,"A3#": "1''T " ,"B3" : "4P/2'T",
"C4" : "3'P/4T","C4#": "2''T " ,"D4" : "5P/3'T" ,"D4#": "2''P/3''T" ,"E4" : "4'P/5T","F4" : "3''P/4'T",
"F4#": "6T" ,"G4" : "6P/5'T","G4#": "4''P/4''T" ,"A4" : "5'P/7T" ,"A4#": "5''P/5''T" ,"B4" : "7P/6'T",
"C5" : "6'P/8T","C5#": "6''T " ,"D5" : "8P/7'T" ,"D5#": "6''P/7''T ","E5" : "7'P/9T","F5" : "7''P/8'T",
"F5#": "10T" ,"G5" : "9P/9'T","G5#": "8''P/8''T" ,"A5" : "8'P/11T" ,"A5#": "9''T" ,"B5" : "10P/10'T",
"C6" : "9'P/12T" ,"C6#": "10''T ","D6" : "11P/11'T" ,"D6#": "10''P" ,"E6" : "10'P" ,"F6" : "",
"F#6" : "" ,"G6" : "12P" ,"G6#": "" ,"A6" : "11'P" ,
},
// Clavier Loffet 3 rangs
"GCLoffet3R" : {
description: "Sol/Do Bernard Loffet 3 rangs",
"C3" : "" ,"C3#": "" ,"D3" : "2P" ,"D3#": "" ,"E3" : "1'P/1T","F3": "1'T",
"F3#": "2T" ,"G3" : "3P/2'P" ,"G3#": "1''P" ,"A3" : "2''P/3T" ,"A3#": "1''T" ,"B3": "4P/2'T",
"C4" : "3'P/4T","C4#": "2''T " ,"D4" : "5P/3'T" ,"D4#": " 3''P" ,"E4" : "4'P/5T","F4": "4'T",
"F4#": "6T" ,"G4" : "6P/5'P" ,"G4#": "4''P/4''T" ,"A4" : "7T/5'T" ,"A4#": "5''T" ,"B4": "7P/6'T",
"C5" : "6'P/8T","C5#": "6''T" ,"D5" : "8P/7'T" ,"D5#": "6''P" ,"E5" : "7'P/9T","F5": "8'T",
"F5#": "10T" ,"G5" : "8'P/9P/7''T","G5#": "7''P/8''T ","A5" : "8''P/9'T/11T","A5#": "9''T " ,"B5": "10P/10'T",
"C6" : "9'P" ,"C6#": "" ,"D6" : "11P" ,"D6#": "9''P " ,"E6" : "10'P",
},
// Castagnari G/C FH
"GCCasta3RFH" : {
description: "Sol/Do Castagnari 3 rangs FH",
"C3" : "" ,"C3#": "" ,"D3" : "2P" ,"D3#": "" ,"E3" : "1'P/1T","F3" : "1'T",
"F3#": "2T" ,"G3" : "3P/2'P" ,"G3#": "1''P" ,"A3" : "2''P/3T" ,"A3#": "1''T" ,"B3" : "4P/2'T",
"C4" : "3'P/4T","C4#": "2''T " ,"D4" : "5P/3'T" ,"D4#": "3''P" ,"E4" : "4'P/5T","F4" : "4'T",
"F4#": "6T" ,"G4" : "6P/5'P/3''T" ,"G4#": "4''P/4''T" ,"A4" : "5''P/7T/5'T","A4#": "5''T" ,"B4" : "7P/6'T",
"C5" : "6'P/8T","C5#": "6''T" ,"D5" : "8P/7'T" ,"D5#": "6''P" ,"E5" : "7'P/9T","F5" : "8'T",
"F5#": "10T" ,"G5" : "8'P/9P/7''T" ,"G5#": "7''P/8''T ","A5" : "8''P/9'T/11T","A5#": "9''T " ,"B5" : "10P/10'T",
"C6" : "9'P" ,"C6#": "10''T" ,"D6" : "11P" ,"D6#": "9''P " ,"E6" : "10'P" ,"G6#": "10''P"
},
// Castagnari G/C JPL
"GCCasta3RJPL" : {
description: "Sol/Do Castagnari 3 rangs JPL",
"A2" : "" ,"B2": "1P" ,
"C3#": "" ,"D3" : "2P" ,"D3#": "" ,"E3" : "1'P/1T" ,"F3" : "1'T" ,
"F3#": "2T" ,"G3" : "3P/2'P/1''T" ,"G3#": "1''P" ,"A3" : "2''P/3T" ,"A3#": "2''T" ,"B3" : "4P/2'T",
"C4" : "3'P/4T" ,"C4#": "3''T " ,"D4" : "5P/3'T" ,"D4#": "3''P" ,"E4" : "4'P/5T" ,"F4" : "4'T",
"F4#": "6T" ,"G4" : "6P/5'P/4''T" ,"G4#": "4''P" ,"A4" : "5''P/7T/5'T" ,"A4#": "5''T" ,"B4" : "7P/6'T",
"C5" : "6'P/8T" ,"C5#": "6''T" ,"D5" : "8P/7'T" ,"D5#": "6''P" ,"E5" : "7'P/9T" ,"F5" : "8'T",
"F5#": "10T" ,"G5" : "8'P/9P/7''T" ,"G5#": "7''P" ,"A5" : "8''P/9'T/11T","A5#": "8''T" ,"B5" : "10P/10'T",
"C6" : "9''T/9'P","C6#": "" ,"D6" : "11P" ,"D6#": "9''P/11'T" ,"E6" : "10'P/10''T","F6" : "",
"F6#": "" ,"G6" : "12'P" ,"G6#": "11'P",
},
// Clavier 5' inversé
"GC5Inv" : {
description: "Sol/Do 5' Inversé",
"C3" : "" ,"C3#": "" ,"D3" : "2P" ,"D3#": "" ,"E3" : "1'P" ,"F3" : "1'T",
"F3#": "2T" ,"G3" : "3P/2'P","G3#": "" ,"A3" : "3T" ,"A3#": "" ,"B3" : "4P/2'T",
"C4" : "3'P/4T","C4#": "" ,"D4" : "5P/3'T","D4#": "" ,"E4" : "4'P/5T","F4" : "4'T",
"F4#": "6T" ,"G4" : "6P/5'T","G4#": "" ,"A4" : "7T/5'P" ,"A4#": "" ,"B4" : "7P/6'T",
"C5" : "6'P/8T","C5#": "" ,"D5" : "8P/7'T","D5#": "" ,"E5" : "7'P/9T","F5" : "8'T",
"F5#": "10T" ,"G5" : "8'P/9P","G5#": "" ,"A5" : "9'T/11T","A5#": "" ,"B5" : "10P/10'T",
"C6" : "9'P" ,"C6#": "" ,"D6" : "11P" ,"D6#": "" ,"E6" : "10'P" ,
},
// Clavier François Heim
"GCHeim2" : {
description: "Sol/Do, Heim 2",
"B2" : "1P" ,
"C3" : "0'P " ,"C3#": "" ,"D3" : "2P" ,"D3#": "0''P" ,"E3" : "1'P/1T","F3" : "1''P/0'T",
"F3#": "2T" ,"G3" : "3P/1'T","G3#": " 2''P/0''T","A3" : "3T/2'P" ,"A3#": "1''T " ,"B3" : "4P/2'T",
"C4" : "3'P/4T","C4#": "2''T " ,"D4" : "5P/3'T" ,"D4#": "3''P/3''T" ,"E4" : "4'P/5T","F4" : "4''P/4'T",
"F4#": "6T" ,"G4" : "6P/5'T","G4#": "5''P/4''T" ,"A4" : "5'P/7T" ,"A4#": "5''T" ,"B4" : "7P/6'T",
"C5" : "6'P/8T","C5#": "6''T " ,"D5" : "8P/7'T" ,"D5#": "6''P/7''T ","E5" : "7'P/9T","F5" : "7''P/8'T",
"F5#": "10T" ,"G5" : "9P/9'T","G5#": "8''P/8''T" ,"A5" : "8'P/11T" ,"A5#": "9''T" ,"B5" : "10P/10'T",
"C6" : "9'P" ,"C6#": "10''T ","D6" : "11P/11'T" ,"D6#": "8''P" ,"E6" : "10'P" ,"F6" : "9''P",
"F6" : "" ,"G6" : "" ,"G6#": "" ,"A6" : "11'P" ,
},
// Clavier Milleret Pignol
"GCMillPign" : {
description: "Milleret/Pignol",
"B2" : "",
"C3" : "","C3#": "0P","D3" : "1P","D3#": " 0''P","E3" : "0'P/1T","F3" : "0''P",
"F3#": "1''P/2T","G3" : "3P/0'T","G3#": "1'T","A3" : "3T/2'P","A3#": "1'P/0''T ","B3" : "4P/2'T",
"C4" : "3'P/4T","C4#" : "1''T ","D4" : "5P/3'T","D4#" : "2''P/2''T","E4" : "4'P/5T","F4" : "3''P/4'T",
"F4#": "4''P/6T","G4" : "6P/3''T","G4#" : "5'T ","A4" : "5'P/7T","A4#" : "4''T ","B4" : "7P/6'T",
"C5" : "6'P/8T","C5#" : "5''T","D5" : "8P/7'T","D5#" : "5''P/6''T","E5" : "7'P/9T","F5" : "6''P/8'T",
"F5#": "7''P/10T","G5" : "9P/7''T","G5#" : "9'T","A5" : "8'P/11T","A5#" : "8''T","B5" : "10P/10'T",
"C6" : "9'P","C6#": "9''T ","D6" : "11P/11'T","D6#": "8''P ","E6" : "10'P", "F6" : "9''P",
"F6#" : "10''P","G6" : "11'P","G6#" : "","A6" : "",
},
"C#DIrish" : {
description: "C#/D Irish machine",
"C3#": "0P " ,"D3" : "0'P","D3#": "" ,"E3" : "" ,"F3" : "1P",
"F3#": "1'/0T" ,"G3" : "0'T","G3#": "2P ","A3" : "2'P","A3#": "1T","B3" : "1'T",
"C4" : "2T" ,"C4#": "3P/2'T ","D4" : "3'P","D4#" : "3T ","E4" : "3'T","F4" : "4P",
"F4#": "4'P/4T" ,"G4" : "4'T","G4#" : "5P","A4" : "5'P","A4#" : "5T","B4" : "5'T",
"C5" : "6T" ,"C5#": "6P/6'T ","D5" : "6'P","D5#" : "7T ","E5" : "7'T","F5" : "7P",
"F5#": "7'P/8T" ,"G5" : "8'T","G5#" : "8P","A5" : "8'P","A5#" : "9T","B5" : "9'T",
"C6" : "10T" ,"C6#": "9P/10'T ","D6" : "9'P","D6#": "11T","E6" : "","F6" : "10T",
"F6#'" : "10'P" ,"G6" : "10'P","G6#'" : "11P",
},
"BCIrish": {
description: "BC Irish machine",
"B2": "0P",
"C3#": "0'P","D3" : "" ,"D3#": "1P" ,"E3" : "1'P/0'T","F3" : "",
"F3#": "2P", "G3" : "2'P","G3#": "1T" ,"A3" : "" ,"A3#": "2T" ,"B3" : "3P",
"C4" : "3'P","C4#" : "2''P" ,"D4" : "4P","D4#" : "1'''P" ,"E4" : "4'P","F4" : "3''P",
"F4#": "2'''P","G4" : "5P","G4#" : "5'P" ,"A4" : "4''P" ,"A4#" : "3'''P" ,"B4" : "6P",
"C5" : "6'P","C5#" : "5''P" ,"D5" : "7P","D5#" : "4'''P" ,"E5" : "7'P","F5" : "6''P",
"F5#": "5'''P","G5" : "8P","G5#" : "8'P" ,"A5" : "7''P" ,"A5#" : "6'''P" ,"B5" : "9P",
"C6" : "9'P","C6#": "8''P","D6" : "10P" ,"D6#": "7'''P" ,"E6" : "110'P" ,"F6" : "9''P",
"F6#'": "8'''P","G6" : "11P" ,"G6#'": "11'P", "A6": "10''P", "A6#": "9'''P", "B6": "",
"C7" : "12''P", "C7#" : "11''P", "D7" : "", "D7#" : "10'''P",
},
}
// Critères à choisir dans la boîte de dialogue
property var parametres: {
"sensFa" : 3, // 1 Fa Tirés / 2 Fa Poussés / 3 Fa dans les deux sens
"sensSol" : 3, // 1 Sol Tirés / 2 Sol Poussés / 3 Sol dans les deux sens
"typeJeu" : 3, // 1 C privilégié / 2 G privilégié / 3 Jeu croisé
"typePossibilite": 2, // 2 Afficher toutes les possibilités / 1 n'afficher qu'une seule possibilité
"typeTablature": "CACB", // tablature CACB ou Corgeron ou DES (mono ligne)
"modeleClavierMD": "GCStd2R21", // Par défaut, modèle Sol/Do 2 rangs sans altération touches 1 et 1'
"modeleClavierMG": "GC8B" // Par défaut, G/C 8 basses
}
// -------------------------------------------------------------------
// Description de la fenêtre de dialogue
//--------------------------------------------------------------------
GridLayout {
id: 'mainLayout'
anchors.fill: parent
anchors.margins: 10
columns: 2
Label {
Layout.columnSpan : 2
width: parent.width
wrapMode: Label.Wrap
horizontalAlignment: Qt.AlignCenter
font.bold: true
text: (lang == "FR") ? qsTr("Tablatures pour accordéons diatoniques v" + version) :
qsTr("Tablature for diatonic accordion v" + version)
}
//------------------------------------------------
// Type d'accordéon et plan de clavier Main DROITE
//------------------------------------------------
Label {
horizontalAlignment: Qt.AlignRigth
text: (lang == "FR") ? qsTr("Clavier MD : ") :
qsTr("Keyboard LH : ")
}
ComboBox {
id: comboModeleClavierMD
width: parent.width
//editable: true
model: [
{ text: qsTr("G/C 2 R whithout alteration"), value: "GCStd2R21" },
{ text: qsTr("G/C 2 R with alterations (1 and 1')"), value: "GCAlt2R21" },
{ text: qsTr("G/C 2 R N.A.M.D.") , value: "GDNAMD2R" },
{ text: qsTr("G/C 3 R N.A.M.D.") , value: "GDNAMD3R" },
{ text: qsTr("G/C 3 R Bernard Loffet"), value: "GCLoffet3R" },
{ text: qsTr("G/C 3 R Francois Heim 1"), value: "GCCasta3RFH" },
{ text: qsTr("G/C 3 R Jean-Pierre Leray"), value: "GCCasta3RJPL" },
{ text: qsTr("G/C 2 R inverted 5'"), value: "GC5Inv" },
{ text: qsTr("G/C 3 R Francois Heim 2"), value: "GCHeim2" },
{ text: qsTr("G/C 3 R Milleret/Pignol"), value: "GCMillPign" },
{ text: qsTr("C#/D 2 R Irish"), value: "C#DIrish" },
{ text: qsTr("B/C 2 R Irish"), value: "BCIrish" }
]
// Récupère le code du modèle de clavier
onActivated: { parametres["modeleClavierMD"] = model[index].value
// console.log("Modele de clavier : " + parametres.modeleClavierMD)
}
}
//------------------------------------------------
// Type d'accordéon et plan de clavier Main GAUCHE
//------------------------------------------------
Label {
horizontalAlignment: Qt.AlignRigth
text: (lang == "FR") ? qsTr("Clavier MG : ") :
qsTr("Keyboard LH : ")
}
ComboBox {
id: comboModeleClavierMG
model: [
{ text: qsTr("G/C 8 Bass"), value: "GC8B" },
{ text: qsTr("G/C 8 Bass N.A.M.D."), value: "GC8BNMAD" },
{ text: qsTr("G/C 12 Bass"), value: "GC12B" },
{ text: qsTr("G/C 18 Bass"), value: "GC18B" },
{ text: qsTr("G/C 12/18 Bass N.A.M.D."), value: "GC12BNAMD" },
{ text: qsTr("C#D 8 Bass"), value: "C#D8B" },
{ text: qsTr("A/D 8 Bass"), value: "AD8B" },
{ text: qsTr("B/C 8 Bass"), value: "BC8B" },
]
// Récupère le code du modèle de clavier
onActivated: { parametres["modeleClavierMG"] = model[index].value
// console.log("Modele de clavierMG : " + parametres.modeleClavierMG)
}
}
//-------------------------------------------------------------------------
// Sens des mesures de Sol 1 = tiré / 2 = poussé / 3 = dans les deux sens
//-------------------------------------------------------------------------
GroupBox {
title: (lang=="FR")?qsTr("Sens pour les mesures de G (Sol/Do) ou A (La/Ré)"):
qsTr("Push or Pull for G measure (G/C) or A measure (A/D)")
Layout.columnSpan : 2
RowLayout {
ExclusiveGroup { id: tabPositionGroupSOL }
RadioButton {
text: (lang=="FR")?qsTr("Dans les 2 sens"):qsTr("Push AND Pull")
checked: (parametres.sensSol==3)
exclusiveGroup: tabPositionGroupSOL
onClicked : {
parametres.sensSol = 3
//console.log("Sens Sol " + parametres.sensSol);
}
}
RadioButton {
text: (lang=="FR")?qsTr("Privilégier le tiré"):qsTr("Pull priority")
checked: (parametres.sensSol==1)
exclusiveGroup: tabPositionGroupSOL
onClicked : {
parametres.sensSol = 1
//console.log("Sens Sol " + parametres.sensSol);
}
}
RadioButton {
text: (lang=="FR")?qsTr("Privilégier le poussé"):qsTr("Push priority")
exclusiveGroup: tabPositionGroupSOL
checked: (parametres.sensSol==2)
onClicked : {
parametres.sensSol = 2
//console.log("Sens Sol " + parametres.sensSol);
}
}
}
}
//------------------------------------------------
// Sens des mesures de Fa 1 = tiré / 2 = poussé / 3 = dans les deux sens
//------------------------------------------------
GroupBox {
title: (lang=="FR")?qsTr("Sens pour les mesures de F (Sol/Do) ou de G (La/Ré)"):
qsTr("Push or Pull for F measure (G/C) or G measure (A/D)")
Layout.columnSpan : 2
RowLayout {
ExclusiveGroup { id: tabPositionGroupFA }
RadioButton {
text:(lang=="FR")?qsTr("Dans les 2 sens"):qsTr("Push AND Pull")
checked: (parametres.sensFa==3)
exclusiveGroup: tabPositionGroupFA
onClicked : {
parametres.sensFa = 3
//console.log("Sens Fa " + parametres.sensFa);
}
}
RadioButton {
text: (lang=="FR")?qsTr("Privilégier le tiré"):qsTr("Pull priority")
checked: (parametres.sensFa==1)
exclusiveGroup: tabPositionGroupFA
onClicked : {
parametres.sensFa = 1
//console.log("Sens Fa " + parametres.sensFa);
}
}
RadioButton {
text: (lang=="FR")?qsTr("Privilégier le poussé"):qsTr("Push priority")
checked: (parametres.sensFa==2)
exclusiveGroup: tabPositionGroupFA
onClicked : {
parametres.sensFa = 2
//console.log("Sens Fa " + parametres.sensFa);
}
}
}
}
//------------------------------------------------
// Sens des mesures de Sol 1 = C / 2 = G / 3 = Croisé
//------------------------------------------------
GroupBox {
title: (lang=="FR")?qsTr("Jeu Tiré/Poussé ou Croisé"):qsTr("Crossed or Push/Pull playing")
Layout.columnSpan : 2
RowLayout {
ExclusiveGroup { id: tabPositionGroupCroise }
RadioButton {
text: (lang=="FR")?qsTr("Jeu en croisé"):qsTr("Crossed playing")
exclusiveGroup: tabPositionGroupCroise
checked: (parametres.typeJeu==3)
onClicked : {
parametres.typeJeu = 3
//console.log("Type de jeu " + parametres.typeJeu);
}
}
RadioButton {
text:(lang=="FR")?qsTr("Privilégier rang 1"):qsTr("Row #1 priority")
checked: (parametres.typeJeu==1)
exclusiveGroup: tabPositionGroupCroise
onClicked : {
parametres.typeJeu = 1
//console.log("Type de jeu " + parametres.typeJeu);
}
}
RadioButton {
text:(lang=="FR")?qsTr("Privilégier rang 2"):qsTr("Row #2 priority")
checked: (parametres.typeJeu==2)
exclusiveGroup: tabPositionGroupCroise
onClicked : {
parametres.typeJeu = 2
//console.log("Type de jeu " + parametres.typeJeu);
}
}
}
}
//------------------------------------------------
// Simple ou double possibilité
//------------------------------------------------
GroupBox {
title: (lang=="FR")?qsTr("Lorsque plusieurs touches correspondent à une même note"):
qsTr("When several keys correspond to a same note")
Layout.columnSpan : 2
RowLayout {
ExclusiveGroup { id: tabPositionGroupPossibilite }
RadioButton {
text:(lang=="FR")?qsTr("Afficher toutes les possibilités"):
qsTr("Show all possibilities")
checked : (parametres.typePossibilite==2)
exclusiveGroup: tabPositionGroupPossibilite
onClicked : {
parametres.typePossibilite = 2
//console.log("Possibilités " + parametres.typePossibilite);
}
}
RadioButton {
text:(lang=="FR")?qsTr("N'afficher qu'une seule possibilité"):
qsTr("Show only one possibility")
checked : (parametres.typePossibilite==1)
exclusiveGroup: tabPositionGroupPossibilite
onClicked : {
parametres.typePossibilite = 1
//console.log("Possibilités " + parametres.typePossibilite);
}
}
}
}
//------------------------------------------------
// Tablature sur une seule ligne ou sur deux
//------------------------------------------------
GroupBox {
Layout.columnSpan : 2
title: (lang=="FR")?qsTr("Tablature : "):
qsTr("Tablature : ")
RowLayout {
ExclusiveGroup { id: tabPositionGroupNbLigne }
RadioButton {
text:(lang=="FR")?qsTr("C.A.C.B."):
qsTr("C.A.C.B.")
exclusiveGroup: tabPositionGroupNbLigne
checked : (parametres.typeTablature =="CACB")
onClicked : {
parametres.typeTablature = "CACB"
// console.log("Type de Tablature " + parametres.typeTablature);
}
}
RadioButton {
text:(lang=="FR")?qsTr("JM.Corgeron"):
qsTr("JM.Corgeron")
exclusiveGroup: tabPositionGroupNbLigne
checked : (parametres.typeTablature =="Corgeron")
onClicked : {
parametres.typeTablature = "Corgeron"
// console.log("Type de Tablature " + parametres.typeTablature);
}
}
RadioButton {
text:(lang=="FR")?qsTr("D.E.S."):
qsTr("D.E.S.")
checked : (parametres.typeTablature=="DES")
exclusiveGroup: tabPositionGroupNbLigne
onClicked : {
parametres.typeTablature = "DES"
// console.log("Type de Tablature " + parametres.typeTablature);
}
}
}
}
//-----------------------------------------------
Button {
id: okButton
isDefault: true
Layout.columnSpan: 1
text: qsTr("OK")
onClicked: {
// Mémorise les parametres pour la prochaine fois
myParameterFile.write(JSON.stringify(parametres).replace(/,/gi ,",\n"))
curScore.startCmd();
// Here start the job --------------
doTablature();
// ---------------------------------
curScore.endCmd();
Qt.quit();
}
}
Button {
id: cancelButton
Layout.columnSpan: 1
text: (lang=="FR")?qsTr( "Annuler"):qsTr("Cancel")
onClicked: {
Qt.quit();
}
}
} // GridLayout
// ------------------------------------------------------
//-------------------------------------------------------
// Début du code
//-------------------------------------------------------
onRun: {
if (!curScore) Qt.quit(); // Si pas de partition courrante, sortie du plugin
if (typeof curScore === 'undefined') Qt.quit();
//------------------------------------------------------------------------------
// Lecture du fichier de parametres
//------------------------------------------------------------------------------
parametres = JSON.parse(myParameterFile.read())
//------------------------------------------------------------------------------
// Lecture du fichier des claviers -----------------------------------------------------
// console.log("Lecture du fichier des claviers : " + myKeyboardsFile.source)
// planClavier = JSON.parse(myKeyboardsFile.read())
// console.log("Claviers : " + JSON.stringify(planClavier))
// Lecture du fichier des claviers -----------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// initialisation des comboBox selon les parametres mémorisés dans le fichiers de parametres
//------------------------------------------------------------------------------
var numClavier
// Récupère le clavier Rigth Hand dans la comboBox
comboModeleClavierMD.currentIndex = 0
for (numClavier = 0; numClavier < comboModeleClavierMD.model.length; numClavier ++) {
if (comboModeleClavierMD.model[numClavier].value == parametres.modeleClavierMD)
comboModeleClavierMD.currentIndex = numClavier
}
// Récupère le clavier Left Hand dans la comboBox
comboModeleClavierMG.currentIndex = 0
for (numClavier = 0; numClavier < comboModeleClavierMG.model.length; numClavier ++) {
if (comboModeleClavierMG.model[numClavier].value == parametres.modeleClavierMG)
comboModeleClavierMG.currentIndex = numClavier
}
//------------------------------------------------------------------------------
}
// ------------------------------------------------------------------------------
// fonction addTouche(cursor, note, accord)
// Cette fonction ajoute le numéro de la touche à actionner en fonction de l'accord main gauche
// Entrée : curseur positionné à l'endroit où il faut insérer le numéro de la touche
// note à traiter, cette fonction ne traite qu'une seile note à la fois
// le dernier accord main gauche rencontré pour choisir entre tiré et poussé lorsque c'est possible
// Si la note n'existe pas en poussé mais qu'elle existe en tiré, celle-ci est proposée quelque soit l'accord (A, F, F#))
// et réciproquement
// Les critères définis par l'utilisateur dans la boite de dialogue sont utilisés ici
//------------------------------------------------------------------------------
function addTouche(cursor, note, accord) {
var textPousse, textTire, textAlt
// ------------------------------------------------------------------------
// Choix entre STAFF_TEXT et LYRICS : Si tablature sur 2 lignes, LYRICS, sinon STAFF
//------------------------------------------------------------------------------
// console.log("typePartition = " + parametres.typeTablature)
if (parametres.typeTablature=="DES") {
textPousse = newElement(Element.STAFF_TEXT)
textTire = newElement(Element.STAFF_TEXT)
textAlt = newElement(Element.STAFF_TEXT)
} else {
textPousse = newElement(Element.LYRICS)
textTire = newElement(Element.LYRICS)
textAlt = newElement(Element.LYRICS)
}
textPousse.text = textTire.text = textAlt.text = ""
// ------------------------------------------------------------------------
// Nettoyage des accords enrichis, transformation en accord de base
//------------------------------------------------------------------------------
// console.log("Accord avant : " + accord)
// Supression de la basse dans la notation Am/C
accord = accord.split("\/")[0]
// Transforme les bémols en dièses
var transBemol = { "AB":"G#","BB":"A#","CB":"B","DB":"C#","EB":"D#","FB":"E","GB":"F#" }
if (accord.match(/^[A-G]B/)) accord = transBemol[accord[0]+"B"]
// Supression de M m - sus add 7 6 9 etc dans Am7(b5)
if (!accord.match("#")) accord = accord[0]
else accord = accord[0] + "#"
// console.log("Accord après : " + accord)
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Fabrication par calcul du nom de la note de C0 à B9
//------------------------------------------------------------------------------
// note.pitch contient le numéro de la note dans l'univers MuseScore.
var noteNames = ["C","C#","D","D#","E","F","F#","G","G#","A","A#","B"]
var octave = Math.floor(note.pitch / 12) - 1 // Numéro de l'octave
var noteName = noteNames[note.pitch % 12] // Cherche la note dans le tableau du nom des notes
if (noteName.match("#")) // Ajoute l'octave à ce nom de note (conservation du #)
noteName = noteName[0] + octave + noteName[1]
else
noteName += octave
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Récupération du numéro des touches diato à afficher selon le modèle de clavier choisi
//------------------------------------------------------------------------------
var noBouton = planClavier[parametres.modeleClavierMD][noteName]
if (!noBouton) noBouton = ""
// console.log("Note : " + noteName +
// " noBouton : " + noBouton)
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Variable pour le jeu en Tiré/Poussé
var indexDoubleSens = 0
// ------------------------------------------------------------------------
// Recherche des boutons Tirés et Poussés, formatage du numéro des touches
// la variable noBouton peut contenir :
// xP ou xT pour une seule touche X en Tiré ou en Poussé
// xP/xT ou xT/xP pour deux touches en Tiré Poussé
// xP/yP ou xT/yT pour deux touches en Poussé Tiré
// xP/yP/zT pour trois touches , etc...
var tabBouton = noBouton.split("/") // Découpage selon les slash
// console.log("tabBouton.length : " + tabBouton.length)
var i = 0
for (i = 0 ; i < tabBouton.length ; i++) {
// console.log("tabBouton["+i+"] : " + tabBouton[i])
if (tabBouton[i].match("P")) textPousse.text += tabBouton[i].replace("P","") + "/"
if (tabBouton[i].match("T")) textTire.text += tabBouton[i].replace("T","") + "/"
}
if (textPousse.text.match("/$")) textPousse.text = textPousse.text.substr(0,textPousse.text.length -1)
if (textTire.text.match("/$")) textTire.text = textTire.text.substr(0,textTire.text.length -1)
// console.log("Text Tire : " + textTire.text + " TextPousse : " + textPousse.text)
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Type de Jeu croise, tiré/poussé
// Si le jeu est en croisé, on tient compte des accords pour choisir le sens
// Si le jeu est en tiré poussé, on ne tient pas compte des accords
switch (parametres.typeJeu) {
case 3 : // Jeu en croisé, on tient compte des accords
if (tabClavierMainGauche[parametres.modeleClavierMG]["Tire"].match("-"+accord+"-"))
if (textTire.text != "")
textPousse.text = "";
if (tabClavierMainGauche[parametres.modeleClavierMG]["Pousse"].match("-"+accord+"-"))
if (textPousse.text != "")
textTire.text = "";
if (tabClavierMainGauche[parametres.modeleClavierMG]["2sens"].match("-"+accord+"-"))
{
if ((parametres.modeleClavierMG.match("^GC") && accord.match("F")) ||
(parametres.modeleClavierMG.match("^AD") && accord.match("G")) ) {
switch (parametres.sensFa) {
case 1 : // Fa (Sol/Do) ou G (La/Ré) en tiré uniquement
if (textTire.text != "") textPousse.text = ""; // supression du texte poussé
break;
case 2 : // Fa (Sol/Do) ou G (La/Ré) en poussé uniquement
if (textPousse.text != "") textTire.text = ""; // supression du texte tiré
break;
}
}
if ( (parametres.modeleClavierMG.match("^GC") && accord.match("G")) ||
(parametres.modeleClavierMG.match("^AD") && accord.match("A")) )
{
switch (parametres.sensSol) {
case 1 : // Sol (Sol/Do) ou La (La/Ré) en tiré uniquement
if (textTire.text != "") textPousse.text = ""; // supression du texte poussé
break;
case 2 : // Sol (Sol/Do) ou La (La/Ré) en poussé uniquement
if (textPousse.text != "") textTire.text = ""; // supression du texte tiré
break;
}
}
}
break;
// jeu en tiré poussé sur le rang 2 (de C sur un GC, de D sur une AD)
case 2 :
//Si double possibilité , on ne garde que le rang 2
if (textTire.text.match("/"))
textTire.text = textTire.text.split("/")[(textTire.text.match(/'$/))?1:0]
if (textPousse.text.match("/"))
textPousse.text = textPousse.text.split("/")[(textPousse.text.match(/'$/))?1:0]
if (textTire.text.match("'") && (!textPousse.text.match("'"))) textPousse.text = ""
if (textPousse.text.match("'") && (!textTire.text.match("'"))) textTire.text = ""
indexDoubleSens = (textTire.text.match(/\/.*'$/) || textPousse.text.match(/\/.*'$/)) ? 1 : 0
break;
// jeu en tiré poussé sur le rang 1 (de G sur un GC, de A sur un AD)
case 1 :
// console.log("Priv row 1 , debut, texteTire = " + textTire.text)
// console.log("Priv row 1 , debut, textePous = " + textPousse.text)
//Si double possibilité en tiré, on ne garde que le rang de 1 (pas de ')
if (textTire.text.match("/"))
textTire.text = textTire.text.split("/")[(textTire.text.match(/'$/))?0:1]
//Si double possibilité en poussé, on ne garde que le rang de 1 (pas de ')
if (textPousse.text.match("/"))
textPousse.text = textPousse.text.split("/")[(textPousse.text.match(/'$/))?0:1]
if (!(textTire.text.match(".'")) && (textPousse.text.match(".'"))) textPousse.text = ""
if ( !(textPousse.text.match(".'")) && (textTire.text.match(".'"))) textTire.text = ""
indexDoubleSens = (textTire.text.match(/\/.*'$/) || textPousse.text.match(/\/.*'$/)) ? 1 : 0
break;
}
// Fin du swith "type de jeu"
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Gestion des doubles possibilités pour les notes en double sur le clavier
// Si on ne veut qu'une seule possibilité, on ne garde que la première définie dans le tableau des touches
if (parametres.typePossibilite == 1) {
if (textTire.text.match("/")) textTire.text = textTire.text.split("/")[indexDoubleSens]
if (textPousse.text.match("/")) textPousse.text = textPousse.text.split("/")[indexDoubleSens]
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Gestion du positionnement selon le nombre de lignes de la tablature
// console.log("Type de tablature : " + parametres.typeTablature)
switch(parametres.typeTablature) {
case "Corgeron":
var tabPossibiliteTire = textTire.text.split("/")
var tabPossibilitePousse = textPousse.text.split("/")
var tabRangC = []
var tabRangG = []
var tabRangAlt = []
textTire.autoplace = textPousse.autoplace = textAlt.autoplace = false
// console.log("tabPossibiliteTire : " + JSON.stringify(tabPossibiliteTire))
// console.log("tabPossibilitePousse : " + JSON.stringify(tabPossibilitePousse))
// Répartition entre les rangs Alt, C et G
var i, ia, ic, ig
for (i = ia = ic = ig = 0 ; i < tabPossibiliteTire.length ; i++) {
if (tabPossibiliteTire[i] != "")
if (tabPossibiliteTire[i].match("''"))
tabRangAlt[ia++] = "" + tabPossibiliteTire[i] + ""
else if (tabPossibiliteTire[i].match("'"))
tabRangC[ic++] = "" + tabPossibiliteTire[i] + ""
else
tabRangG[ig++] = "" + tabPossibiliteTire[i] + ""
}
for (i = 0 ; i < tabPossibilitePousse.length ; i++) {
if (tabPossibilitePousse[i] != "")
if (tabPossibilitePousse[i].match("''"))
tabRangAlt[ia++] = tabPossibilitePousse[i]
else if (tabPossibilitePousse[i].match("'"))
tabRangC[ic++] = tabPossibilitePousse[i]
else
tabRangG[ig++] = tabPossibilitePousse[i]
}
textAlt.offsetY = textTire.offsetY = textPousse.offsetY = 2.25
textAlt.verse = 0
textAlt.text = tabRangAlt[0]
for (i = 1 ; i < tabRangAlt.length ; i++) {
if (textAlt[i] != "") textAlt.text += "/" + tabRangAlt[i]
}
// console.log("textAlt.text avant traitement = " + textAlt.text)
if (textAlt.text != "") {
// textAlt.text = textAlt.text.substring(0,textAlt.text.length - 1 )
// console.log("textAlt.text supression / = " + textAlt.text)
textAlt.text = textAlt.text.replace(/(.*)''(.*)/g,"$1$2")
// console.log("textAlt.text supression '' = " + textAlt.text)
textAlt.text = textAlt.text.replace(/(.*)'(.*)/g,"$1$2")
// console.log("textAlt.text supression ' = " + textAlt.text)
}
// console.log("textAlt.text = " + textAlt.text)
textPousse.text = tabRangC[0]
textPousse.verse = 1
for (i = 1 ; i < tabRangC.length ; i++) {
if (tabRangC[i] != "") textPousse.text += "/" + tabRangC[i]
}
// console.log("textPousse.text avant traitement = " + textPousse.text)
if (textPousse.text != "") {
// textPousse.text = textPousse.text.substring(0,textPousse.text.length - 1 )
// console.log("textPousse.text supression / = " + textPousse.text)
textPousse.text = textPousse.text.replace(/(.*)''(.*)/g,"$1$2")
// console.log("textPousse.text supression '' = " + textPousse.text)
textPousse.text = textPousse.text.replace(/(.*)'(.*)/g,"$1$2")
// console.log("textPousse.text supression ' = " + textPousse.text)
}
// console.log("textPousse.text = " + textPousse.text)
textTire.text = tabRangG[0]
textTire.verse = 2
for (i = 1 ; i < tabRangG.length ; i++) {
if (tabRangG[i] != "") textTire.text += "/" + tabRangG[i]
}
// console.log("textTire.text avant traitement = " + textTire.text)
if (textTire.text != "") {
// textTire.text = textTire.text.substring(0,textTire.text.length - 1 )
// console.log("textTire.text supression / = " + textTire.text)
textTire.text = textTire.text.replace(/(.*)''(.*)/g,"$1$2")
// console.log("textTire.text supression '' = " + textTire.text)
textTire.text = textTire.text.replace(/(.*)'(.*)/g,"$1$2")
// console.log("textTire.text supression ' = " + textTire.text)
}
// console.log("textTire.text = " + textTire.text)
break
case "CACB":
textPousse.verse = 0
textTire.verse = 1
textTire.offsetY = textPousse.offsetY = 5.5
textTire.autoplace = textPousse.autoplace = false
break
case "DES": // Rémi Sallard Style
textTire.offsetY = textPousse.offsetY = 0
textTire.autoplace = textPousse.autoplace = true
if (textTire.text != "") textTire.text = "" + textTire.text + ""
break
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
// Pour finir, on affiche le numéro de la touche dans la partition
if (textAlt != "") {
cursor.add(textAlt)
}
if (textTire != "") {
cursor.add(textTire)
}
if (textPousse != "") {
cursor.add(textPousse)
}
// ------------------------------------------------------------------------
}
// ---------------------------------------------------------------------
// Fonction doTablature
//
// Fonction principale appelée par le click que le bouton OK
//----------------------------------------------------------------------
function doTablature() {
var myScore = curScore, // Partition en cours
cursor = myScore.newCursor(), // Fabrique un curseur pour se déplacer dans les mesures
startStaff, // Début de partition ou début de sélection
endStaff, // Fin de partition ou fin de sélection
endTick, // Numéro du dernier élément de la partition ou de la sélection
staff = 0, // numéro de de portée dans partition
accordMg, // Détermine si on est en Poussé ou en Tiré lorsque c'est possible
fullScore = false; // Partition entière ou sélection
// console.log("Entrée dans la fonction doTablature")
// Cherche les portées, on ne travaillera pas sur la dernière portée (en général clé de Fa, Basses et Accords)
// dans le cas de tablature DES, on traite toutes les portées moins 1
// dans le cas Corgeron ou CACB on ne traite que la portée 1 et on écrit sur la porté 2 (si elle existe)
var nbPortees = (parametres.typeTablature == "DES") ? myScore.nstaves : (myScore.nstaves >= 2) ? 2 : 1
//console.log("Nombre de portées =",nbPortees)
// pas d'accord main gauche à priori
accordMg = "zzz"
// ---------------------------------------------------------------------
// Boucle sur chacune des portées sauf la dernière s'il y en a plusieurs
// ---------------------------------------------------------------------
do {
cursor.voice = 0 // Si CACB ou Corgeron, voix 1 de la porté 1
cursor.staffIdx = staff
// Gestion d'une sélection ou du traitement de toute la partition
cursor.rewind(Cursor.SELECTION_START) // rembobine au début de la sélection
if (!cursor.segment) { // pas de sélection
fullScore = true;
startStaff = 0; // commence à la première mesure
endStaff = curScore.nstaves - 1; // et termine à la dernière
} else {
startStaff = cursor.staffIdx; // commence au début de la sélection
cursor.rewind(2); // passe derrière le dernier segment et fixe tick = 0
if (cursor.tick === 0) { // ceci survient lorsque la sélection contient la dernière mesure
endTick = curScore.lastSegment.tick + 1;
} else {
endTick = cursor.tick;
}
endStaff = cursor.staffIdx;
}
if (fullScore) { // si pas de sélection
cursor.rewind(Cursor.SCORE_START) // rembobine au début de la partition
} else { // si sélection
cursor.rewind(Cursor.SELECTION_START)// rembobine au début de la sélection
}
//console.log("Debut de boucle pour chaque élément de la portee " + staff)
// -------------------------------------------------------------------
// Boucle pour chaque élément de la portée ou de la sélection en cours
// -------------------------------------------------------------------
while (cursor.segment && (fullScore || cursor.tick < endTick)) {
var aCount = 0;
// Recherche des accords main gauche (genre Am ou Em ou E7 ...)
var annotation = cursor.segment.annotations[aCount];
while (annotation) {
if (annotation.type == Element.HARMONY){
//console.log("Symbole d'accord : " + annotation.text);
accordMg = annotation.text.toUpperCase()
}
annotation = cursor.segment.annotations[++aCount];
}
// Si le curseur pointe sur une à plusieurs notes jouées simultanément
if (cursor.element && cursor.element.type == Element.CHORD) {
var notes = cursor.element.notes
// Boucle pour chaque note joué en même temps
for (var i = 0; i < notes.length; i++) {
addTouche(cursor, notes[i], accordMg)
} // end for chaque note de l'accord
} // end if CHORD
cursor.next() //Element suivant
} // fin du while cursor.segment et (fullScore || cursor.tick < endTick)
staff+=1 // Portée suivante
} while ((parametres.typeTablature == "DES") && (staff < nbPortees-1) && fullScore) // fin du for chaque portée sauf si sélection
// Rappel : on ne traite pas la dernière portée qui est probablement en clé de fa,
// avec basses et accords. Pour la traiter quand même, il suffit de la sélectionner
} // Fin de la fonction doTablature
} // MuseScore