# -*- coding: ISO-8859-1 -*-
""" capellaScript -- Copyright (c) 2005, 2013 Peter Becker
>>> Stimmumfang : Ermitteln des Stimmumfangs pro Notenzeile
    Der Stimmumfang wird an der ausgewählten Position eingefügt.||
    Ist "vor dem System" ausgewählt, muss der linke Einzug justiert werden. |
    Dieses Script ist nur sinnvoll, wenn das erste System alle Stimmen ( Notenzeilen )
    des Partitur Layouts enthält. ||
    Bei Problemen bitte eine Mail an peter_becker@freenet.de
<<<
<?xml version="1.0" encoding="ISO-8859-1"?>
<info>
  <lang id="en">
    <title>Voice Range: Establishing the Voice Range per Staff</title>
    <descr>
      <p>The voice range will be inserted at the selected position.

If "Before the system" is selected, the left recession has to be
adapted. 

This script has only effect if the the first system contains all
voices ( staves ) of the staff lay-out.

In case of problems pease mail to peter_becker@freenet.de</p>
    </descr>
  </lang>

  <lang id="de">
    <title>Stimmumfang : Ermitteln des Stimmumfangs pro Notenzeile</title>
    <descr>
      <p>Der Stimmumfang wird an der ausgewählten Position eingefügt.

Ist "vor dem System" ausgewählt, muss der linke Einzug justiert
werden.

Dieses Script ist nur sinnvoll, wenn das erste System alle
Stimmen ( Notenzeilen ) des Partitur Layouts enthält.

Bei Problemen bitte eine Mail an peter_becker@freenet.de</p>
    </descr>
  </lang>

  <lang id="nl">
    <title>Stemomvang : Stemomvang per notenbalk vaststellen</title>
    <descr>
      <p>De stemomvang wordt bij de geselecteerde positie ingevoegd.

Is "Vóór het systeem" geselecteerd, dan moet het inspringen
links aangepast worden.
Dit script is heeft alleen effect, wanneer het eerste systeem alle
stemmen ( notenbalken ) van het partituursjabloon bevat.

Bij problemen s.v.p. een mail naar peter_becker@freenet.de</p>
    </descr>
  </lang>
</info>

History:  11.07.05 - Erste Ausgabe
          12.07.05 - Vorzeichen bei Umfang unterdrücken, ist nicht Tonart konform
                   - besseres Alignment durch einfügen nach Schlüssel
                   - falls kein Schlüssel, Anker am Zeilenanfang
                   - vergleicht jetzt abhängig von der Stimmenbezeichnung
                   - Partiturlayout muss mit dem ersten System übereinstimmen
          13.07.05 - Abend wenn Zeile nur mit Pausen
                   - Auswahlmöglichkeit
          15.07.05 - Unterstützung von Sonderzeichen im Layout
          03.08.05 - Erweiterte Darstellung vor dem System
          18.01.10 - Vorzeichen werden, je nach Position relativ zu Vorzeichen, angezeigt
          20.01.10 - Fehler bei mehr als einer Zeile behoben
          22.01.10 - Optik bei "vor dem System" verbessert
          25.01.10 - noch mehr Optik und Auswahl WavyLine und Line
          26.01.10 - Berücksichtigung der Instrumentenbezeichnung
          21.01.11 - Jetzt auch markierte System unterstützt. Damit ist auch Stimmumfang pro Satz möglich
          01.08.11 - Bugfix wenn beim tiefsten Ton ein Halbtonunterschied in unterschiedlichen Systemen
          09.01.12 - 1.2.2 Bugfix in der Formatierung wenn mehrstimmige Zeilen
          17.01.12 - 1.3.0 nur markierte Zeile
          25.01.12 - 1.3.1 Bugfix wenn Partiturlayout nicht mit Partitur übereinstimmt
          25.01.12 - 1.3.2 Bugfix Einrücken wenn "vor dem System" und "markierte Systeme"
          16.03.12 - 1.3.3 Anpassung wegen UTF in 7.1.08
          03.10.13 - 1.3.4 Neue Option : Kopfform
          08.04.18 - 1.3.5 WW Internationalisierung (en-de-nl); OktavierungsSchlüssel gemäß capella 7
                           PB Oktava basso hinzugefügt
          26.06.18 - WW 'Help' besser formattiert. Kleine ÜbersetzungsKorrekturen.
          04.11.20 - 1.3.6 PB noAdjust=true für notelines gesetzt
"""
#--------------------------------------------
english = {
    'score'             :'whole score',
    'systems'           :'only marked systems',
    'establish'         :'Establishment for',
    'staffBegin'        :'at staff beginning',
    'afterClef'         :'after clef',
    'beforeTimeAllKey'  :'before time sign - all staves in the same key',
    'beforeTime1KeyC'   :'before time sign - a staff in C major',
    'beforeSystem'      :'before the system',
    'insVoiceRange'     :'Insert voice range',
    'wavyLine'          :'Wavy line',
    'line'              :'Straight line',
    'connectLine'       :'Connecting line',
    'alignLeft'         :'Alignment left',
    'alignCentered'     :'Alignment centered',
    'alignRight'        :'Alignment right',
    'instrDesign'       :'With instrument designation',
    'normal'            :'Normal',
    'rombus'            :'Rombus',
    'cross'             :'Cross',
    'triangle'          :'Triangle',
    'square'            :'Square',
    'head'              :'Head form',
    'exRecess'          :'Extra recession ',
    'slg'               :'  slg.',
    'addPar'            :'Additional parameters concerning "before the system"',
    'warning1'          :'Warning : 1. If "at staff beginning" is selected, the result will be displayed without taking',
    'warning2'          :'                    account of an eventually following clef !     ',
    'warning3'          :'                2. If there is found a whole measure rest or a multi-measure rest in the first measure',
    'warning4'          :'                    of a staff, the voice range "before the system" will be wrongly positioned before',
    'warning5'          :'                    that staff. Please click on "Help" in order to solve this problem.',
    'title'             :'Voice Range  Version ',
    'info'              :'V o i c e    R a n g e :   Establishing the Voice Range per Staff\n\
\nThe voice range will be inserted at the selected position.\n\
\nThis script makes only sense if the the first system contains all voices \
(staves) of the staff lay-out.\n\
\nIf the first system is not complete, one can place the cue notes in the \
2nd. system. Procedure : Cut off the first system with [Ctr]+[D] and \
[Ctr]+[X] ; apply the script ; insert the system again with [Ctr]+[V].\n\
\nIf \'before the system\' is selected, the left recession has to be adapted. In \
general the instrument designation has to be aligned to the left.\n\
\nIf there is found a whole measure rest or a multi-measure rest in the first \
measure of a staff of the first sytem, due to a mistake in the capella \
python function a false position of this rest will be passed on to this \
script and thus the voice range indication before this staff will be \
wrongly positioned. In order to evade this mistake one puts before \
application of this script a 1/8 rest at the beginning of this staff, formats \
it \'little\', \'invisble\' and \'without value\'. (Since capella 7 bar lines in \
following systems will thereby mostly be shifted. Solution: Cursor in first \
system, [Sh]+[Ctr]+[S] --> [Enter].)\n\
\nThe selection \'before time sign - a staff in C major\' is meant for scores \
with transposing instruments, if a staff is in C major.\n\
\nIn case of problems please mail to peter_becker@freenet.de'
}
german = {
    'score'             :'gesamte Partitur',
    'systems'           :'nur markierte Systeme',
    'establish'         :'Feststellung für',
    'staffBegin'        :'am Zeilenanfang',
    'afterClef'         :'nach Schlüssel',
    'beforeTimeAllKey'  :'vor Taktangabe - alle Zeilen in der selben Tonart',
    'beforeTime1KeyC'   :'vor Taktangabe - eine Zeile in C-Dur',
    'beforeSystem'      :'vor dem System',
    'insVoiceRange'     :'Stimmumfang einfügen',
    'wavyLine'          :'Wellenlinie',
    'line'              :'Strich',
    'connectLine'       :'Verbindungslinie',
    'alignLeft'         :'Ausrichtung linksbündig',
    'alignCentered'     :'Ausrichtung zentriert',
    'alignRight'        :'Ausrichtung rechtsbündig',
    'instrDesign'       :'bei Instrumentenbezeichnung',
    'normal'            :'normal',
    'rombus'            :'Rombus',
    'cross'             :'Kreuz',
    'triangle'          :'Triangel',
    'square'            :'Quadrat',
    'head'              :'Kopfform',
    'exRecess'          :'zusätzliches Einrücken um ',
    'slg'               :'  Zw.',
    'addPar'            :'Zusätzliche Parameter bei "vor dem System"',
    'warning1'          :'Achtung : 1. Wird "am Zeilenanfang" ausgewählt, erfolgt die Darstellung ohne',
    'warning2'          :'                    Berücksichtigung eventuell folgender Schlüssel !',
    'warning3'          :'                2. Steht am Anfang der Partitur in einer Zeile eine Ganze Pause oder',
    'warning4'          :'                    eine Mehrtaktpause, wird der Stimmumfang vor dieser Zeile falsch',
    'warning5'          :'                    positioniert. Klicken sie bitte auf "Hilfe" zur Lösung dieses Problems.',
    'title'             :'Stimmumfang  Version ',
    'info'              :'S t i m m u m f a n g :   Ermitteln des Stimmumfangs pro Notenzeile\n\
\nDer Stimmumfang wird an der ausgewählten Position eingefügt.\n\
\nDieses Script ist nur sinnvoll, wenn das erste System alle Stimmen \
(Notenzeilen) des Partitur Layouts enthält.\n\
\nIst das erste System nicht komplett, kann man die Stichnoten in das 2. \
System setzen. Verfahren : mit [Strg]+[D] und [Strg]+[X] die erste Zeile \
ausschneiden ; Skript ausführen ; mit [Strg]+[V] die Zeile wieder einfügen.\n\
\nIst \'vor dem System\' ausgewählt, muss der linke Einzug justiert werden. \
Im allgemeinen muss die Instrumentenbezeichnung linksbündig \
ausgerichtet werden.\n\
\nSteht im ersten Takt einer Zeile des ersten Systems eine Ganze Pause \
oder eine Mehrtakt-Pause, wird aufgrund eines Fehlers in einer Capella \
Python Funktion die falsche Position dieser Pause an das Skript \
übergeben und somit der Stimmumfang vor dieser Zeile falsch \
positioniert. Als Umgehung setzt man an den Anfang einer solchen \
Zeile vor Ausführung des Skriptes eine kleine Achtelpause und \
formatiert sie unsichtbar und ohne Wert. (Seit Capella 7 werden \
Taktstriche dadurch meistens in folgenden Systeme verschoben. \
Lösung: Kursor im ersten System, [Umsch]+[Strg]+[S] --> [Enter].) \
\nDie Wahl \'vor Taktangabe - eine Zeile in C-Dur\' ist beabsichtigt für \
Partituren mit transponierenden Instrumente, wenn eine Zeile in C-Dur steht.\n\
\nBei Problemen bitte eine Mail an peter_becker@freenet.de'
}
dutch = {
    'score'             :'gehele partituur',
    'systems'           :'slechts gemarkeerde systemen',
    'establish'         :'Vaststelling voor',
    'staffBegin'        :'aan het begin van de notenbalk',
    'afterClef'         :'na de sleutel',
    'beforeTimeAllKey'  :'vóór het maatteken - alle notenblaken dezelfde toonsoort',
    'beforeTime1KeyC'   :'vóór het maatteken - een notenblak in C majeur',
    'beforeSystem'      :'vóór het systeem',
    'insVoiceRange'     :'Stemomvang invoegen',
    'wavyLine'          :'Golflijn',
    'line'              :'Rechte lijn',
    'connectLine'       :'Verbindingslijn',
    'alignLeft'         :'Uitlijning links',
    'alignCentered'     :'Uitlijning gecentreerd',
    'alignRight'        :'Uitlijning rechts',
    'instrDesign'       :'Bij aanduiding instrumenten',
    'normal'            :'Normaal',
    'rombus'            :'Rombus',
    'cross'             :'Kruis',
    'triangle'          :'Driehoek',
    'square'            :'Vierkant',
    'head'              :'Kopvorm',
    'exRecess'          :'Extra inspringen ',
    'slg'               :'  tu.',
    'addPar'            :'Extra parameters m.b.t. "vóór het systeem"',
    'warning1'          :'Let op : 1. Wanneer "aan het begin van de notenbalk" wordt geselecteerd, wordt het resultaat',
    'warning2'          :'                 getoond zonder rekening te houden met met een eventueel verderop aanwezige sleutel !',
    'warning3'          :'             2. Wanneer aan het begin van een partituur in een notenbalk een hele- of een',    
    'warning4'          :'                 meermaatsrust staat wordt de stemomvang "vóór het systeem" vóór die notenbalk',
    'warning5'          :'                 niet goed gepositioneerd. Klik op "Help" voor het oplossen van dit probleem.', 
    'title'             :'Stemomvang  Versie ',
    'info'              :'S t e m o m v a n g :   Stemomvang per notenbalk vaststellen.\n\
\nDe stemomvang wordt bij de geselecteerde positie ingevoegd.\n\
\nDit script is alleen bruikbaar, wanneer het eerste systeem alle stemmen \
(notenbalken) van het partituursjabloon bevat.\n\
\nIs het eerste systeem niet compleet, dan kan men de stichnoten bij het \
2e systeem zetten. Procedure: Het 1e systeem met [Ctr]+[D] en [Ctr]+[X] \
afknippen, script toepassen en het 1e systeem terugplaatsen met \
[Ctr]+V.\n\
\nIs \'vóór het systeem\' geselecteerd, dan moet het inspringen links \
aangepast worden. Doorgaans moeten de instrumentaanduidingen \
links worden uitgelijnd.\n\
\nWanneer in de eerste maat van een notenbalken van het eerste systeem \
een hele- of een meermaatsrust staat, wordt door een fout in een \
capella-python functie een onjuiste positie van die rust aan het script \
doorgegeven en daarmee de stemomvang van deze balk verkeerd \
gepositioneerd. Om deze fout te ontwijken plaatst men alvorens het \
script toe te passen een 1/8 rust aan het begin van de notenbalk en \
maakt die \'klein\', \'onzichtbaar\' en \'zonder waarde\'. (Vanaf capella 7 \
verspringen daardoor de maatstrepen meestal in volgende systemen. \
Oplossing : cursor in eerste systeem, [Shift]+[Ctr]+[S] --> [Enter].)\n\
\nDe selectie \'vóór het maatteken - een notenblak in C majeur\' is bedoeld \
voor partituren met transponerende instrumenten, wanneer een \
notenbalk in C majeur staat.\n\
\nBij problemen s.v.p. een mail naar peter_becker@freenet.de'
}

try:
    setStringTable(
        ("en", english),
        ("de", german),
        ("nl", dutch))
except:
    def tr(s):
        return german[s]
#--------------------------------------------

import xml.dom, tempfile
from caplib.capDOM import ScoreChange
from xml.dom.minidom import NodeList, Node, Element
import string

version = '1.3.6'

def insertNewElementNode(el,tagName,ref):
    # add new Node with tagName "tagName" to el 
    global doc
    newChild = doc.createElement(tagName)
    el.insertBefore(newChild,ref)
    return newChild

def addNewElementNode(el,tagName):
    # add new Node with tagName "tagName" to el 
    global doc
    newChild = doc.createElement(tagName)
    el.appendChild(newChild)
    return newChild

def addElementNode(el,tagName):
    # Neue Node zu "el" hinzufügen wenn Node "tagName" nicht existiert
    # ansonsten existierende Node zurückmelden
    global doc
    childs = el.childNodes
    for n in range(childs.length):
        if childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == tagName:
            return childs[n]
    newChild = doc.createElement(tagName)
    el.appendChild(newChild)
    return newChild

def umfangEinsetzen(score, staff, dtief, dhoch, vztief, vzhoch, sy, mode):
    #messageBox('UMFANG', str(dtief) + '\n' + str(vztief) + '\n' + str(dhoch) + '\n' + str(vzhoch))
    global doc, rAr, rWo, rWa, rKf, eEr, syvon, shiftOK
    doc=score.parentNode
    list    = ('C','D','E','F','G','A','B')
    octTief = dtief/7
    octHoch = dhoch/7
    tonTief = dtief-octTief*7
    tonHoch = dhoch-octHoch*7
    pitTief = list[tonTief]+str(octTief)
    pitHoch = list[tonHoch]+str(octHoch)
    anchor = 0
    #y2dist  = ((octHoch-octTief)*3) + ((tonHoch-tonTief)/2) -0.5

    ix = staff.index()
    sys      = score.getElementsByTagName('system')
    staff1   = sys[sy].getElementsByTagName('staff')
    voices   = staff1[ix].getElementsByTagName('voices')
    voice    = voices[0].getElementsByTagName('voice')
    noteObjs = voice[0].getElementsByTagName('noteObjects')
    noteObjs = voice[0].getElementsByTagName('noteObjects')
            
    childs = noteObjs[0].childNodes
    for n in range(childs.length):
        if rWo == 1:                            # Ankerpunkt nach Schlüssel
            if childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'clefSign':
                ch = childs[n+1]
                anchor = 1
                break
        elif rWo == 2 or rWo == 3:              # Ankerpunkt vor Taktangabe
            if childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'timeSign':
                ch = childs[n]
                anchor = 1
                break
        elif rWo == 4:                          # Ankerpunkt an erster Note oder Pause = vor System
            if childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'clefSign':
                clef = childs[n].getAttribute('clef')  # Schlüssel merken
                #messageBox('CLEF',str(clef))
            elif childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'chord':
                ch = childs[n]
                anchor = 1
                break
            elif childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'rest':
                ch = childs[n]
                anchor = 1
                break
    if anchor == 0:                             # ansonsten Anker am Anfang der Zeile
        ch = childs[0]

    #messageBox('SYS',str(voice) + '\n' + str(ix))    
    if rWo <> 4:
        for nn in range(voice.length):
            noteObjs = voice[nn].getElementsByTagName('noteObjects')
            
            childs = noteObjs[0].childNodes
            for n in range(childs.length):
                if rWo == 1:                            # Ankerpunkt nach Schlüssel
                    if childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'clefSign':
                        ch = childs[n+1]
                        anchor = 1
                        break
                elif rWo == 2 or rWo == 3:              # Ankerpunkt vor Taktangabe
                    if childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'timeSign':
                        ch = childs[n]
                        anchor = 1
                        break
                elif rWo == 4:                          # Ankerpunkt an erster Note oder Pause = vor System
                    if childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'clefSign':
                        clef = childs[n].getAttribute('clef')  # Schlüssel merken
                        #messageBox('CLEF',str(clef))
                    elif childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'chord':
                        ch = childs[n]
                        anchor = 1
                        break
                    elif childs[n].nodeType ==childs[n].ELEMENT_NODE and childs[n].tagName == 'rest':
                        ch = childs[n]
                        anchor = 1
                        break
            if anchor == 0:                             # ansonsten Anker am Anfang der Zeile
                ch = childs[0]

            el  = insertNewElementNode(noteObjs[0],'chord',ch)
            du  = addNewElementNode(el,'duration')
            di  = addNewElementNode(el,'display')
            st  = addNewElementNode(el,'stem')
            hds = addNewElementNode(el,'heads')
            hd1 = addNewElementNode(hds,'head')
            hd2 = addNewElementNode(hds,'head')
            al1 = addNewElementNode(hd1,'alter')
            al2 = addNewElementNode(hd2,'alter')
            du.setAttribute('base','1/4')
        
            if rWo <> 3:
                du.setAttribute('noDuration','true')
            
            di.setAttribute('small','true')
            di.setAttribute('xShift','-0.75')
            st.setAttribute('invisible','true')
            #messageBox('Mode',str(mode))
            if mode == '0':
                hd1.setAttribute('pitch',pitHoch)
                al1.setAttribute('step',str(vzhoch))
                hd2.setAttribute('pitch',pitTief)
                al2.setAttribute('step',str(vztief))
            else:
                hd1.setAttribute('pitch','A5')
                hd2.setAttribute('pitch','A5')
                di.setAttribute('invisible','true')
            
            hd1.setAttribute('silent','true')
            hd2.setAttribute('silent','true')
            if rKf <> 0:
                if rKf == 1:
                    shape = 'diamond'
                elif rKf == 2:
                    shape = 'crossCircle'
                elif rKf == 3:
                    shape = 'triangle'
                elif rKf == 4:
                    shape = 'square'
                    
                hd1.setAttribute('shape',shape)
                hd2.setAttribute('shape',shape)

    elif rWo == 4 and mode == '0':
                    
        for note in staff.noteObjs():                       # Auswahl: vor System
            if note.isChord() or note.isRest():             # Ankerpunkt suchen
                anchorPos = note.posX(True)                 # und Position feststellen
                break
                 
        #messageBox('SYS',str(len(sys)) + '\n' + str(syvon))
        leftInd = int(3)
        #messageBox('shiftOK',str(shiftOK))
        if shiftOK == 0:
            if len(sys) > 1:
                if sys[syvon].hasAttribute('leftIndent'):           # sys[1]
                    leftInd = int(sys[syvon].getAttribute('leftIndent'))
                    #messageBox('LI1',str(leftInd))
            else:
                if sys[0].hasAttribute('leftIndent'):
                    leftInd = int(sys[0].getAttribute('leftIndent'))
            leftInd = leftInd + int(13) + int(eEr)                                           
            #messageBox('LI2',str(leftInd) + '    ***    ' + str(anchorPos))
            sys[syvon].setAttribute('leftIndent',str(leftInd))       # sys[0]
            shiftOK = 1
        nlx1 = -anchorPos - 13 
        nlx2 = -anchorPos - 2.4 
        #messageBox('LI',str(leftInd) + '    ***    ' + str(anchorPos) + '\n' + str(nlx1))
        dos  = addElementNode(ch,'drawObjects')
        do   = addNewElementNode(dos,'drawObj')
        nln  = addNewElementNode(do,'notelines')            # Notenlinien davorsetzen
        nlba  = addNewElementNode(do,'basic')               # basic bei Notenlinien hinzufügen
        
        nlba.setAttribute('noAdjust','true')                # für Notenlinien noAdjust=true setzen
      
        nln.setAttribute('y','0')   
        nln.setAttribute('x1',str(nlx1))
        nln.setAttribute('x2',str(nlx2))
        nclx = nlx1
        oct  = 'no'
        if clef[2:3] == '+': oct = '+'
        if clef[2:3] == '-': oct = '-'
        if clef == 'treble' or clef[0:1] == 'G':            # Schlüssel einsetzen
            ncly   = '1'
            clForm = 'A'
            if clef[0:1] == 'G':
                if clef[1:2] == '1': ncly = '2'
        elif clef == 'bass' or clef[0:1] == 'F':
            ncly   = '-1'
            clForm = 'E'
            if clef[0:1] == 'F':
                if clef[1:2] == '3': ncly = '0'
                elif clef[1:2] == '5': ncly = '-2'
        elif clef == 'alto' or clef == 'tenor' or clef[0:1] == 'C':
            ncly   = '0'
            clForm = 'C'
            if clef[0:1] == 'C':
                if clef[1:2] == '1': ncly = '2'
                elif clef[1:2] == '2': ncly = '1'
                elif clef[1:2] == '5': ncly = '-2'
            elif clef == 'tenor': ncly = '-1'
        else:
            ncly   = 0
            clForm = 'noClef'
            clef   = 'treble'
            
        do  = addNewElementNode(dos,'drawObj')
        ncl = addNewElementNode(do,'text')                  # Schlüssel davorsetzen
        ncl.setAttribute('x',str(nclx))
        ncl.setAttribute('y',str(ncly))
        nft = addNewElementNode(ncl,'font')                
        nft.setAttribute('face','capella3')
        nft.setAttribute('height','18')
        nft.setAttribute('weight','0')
        nft.setAttribute('charSet','2')
        nft.setAttribute('pitchAndFamily','0')
        nct = addNewElementNode(ncl,'content')
        if clForm <> 'noClef':
            textNode = doc.createTextNode(clForm)
            nct.appendChild(textNode)

        if oct <> 'no':
            #messageBox('OKT',str(oct))
            if oct == '+': ncly = '-4.35'               ##(WW) war '-4.5'
            if oct == '-': ncly = '4'                   ##(WW) war '4.5' 
            if clef[0:1] == 'F' and oct == '-': ncly = '1.95'    ##(WW) war '2.2'
            elif clef[0:1] == 'F' and oct == '+': ncly = '-3.2'  ##(WW) zugefügt.
            #messageBox('OKT',str(nclx))
            do  = addNewElementNode(dos,'drawObj')
            ncl = addNewElementNode(do,'text')              # Oktavierung davorsetzen
            ncl.setAttribute('x',str(nclx+0.5))         ##(WW) war  '+1.1'
            ncl.setAttribute('y',str(ncly))
            if clef[0:1] == 'F' and oct == '-':         ##(WW) Zeile zugefügt
                ncl.setAttribute('x',str(nclx-0.6))     ##(WW) Zeile zugefügt
            elif clef[0:1] == 'F' and oct == '+':       ##(WW) Zeile zugefügt
                ncl.setAttribute('x',str(nclx+0.3))     ##(WW) Zeile zugefügt
            nft = addNewElementNode(ncl,'font')                
            nft.setAttribute('face','capella3')
            nft.setAttribute('height','18')     ##(WW) war '15'
            nft.setAttribute('weight','0')
            nft.setAttribute('charSet','2')
            nft.setAttribute('pitchAndFamily','0')
            nct = addNewElementNode(ncl,'content')
            textNode = doc.createTextNode('þ')  ##(WW) war '8'
            nct.appendChild(textNode)

        posHoch = getNotePos(pitHoch, clef)                 # Position der oberen Note ermitteln          
        insertNote(dos, nclx, nct, posHoch, vzhoch, '1')    # Note einsetzen
        insertStrich(dos, nclx, nct, posHoch, '1')          # Hilfslinien zeichnen
        posTief = getNotePos(pitTief, clef)                 # Position der unteren Note ermitteln   
        insertNote(dos, nclx, nct, posTief, vztief, '0')    # Note einsetzen
        insertStrich(dos, nclx, nct, posTief, '0')          # Hilfslinien zeichnen
        insertWavy(dos, nclx, nct, posHoch+0.8, posTief-0.8)# mit Wellenlinie verbinden

        layout = score.getElementsByTagName('layout')     # Formatieren Instrumentenbezeichnung
        instNa = layout[0].getElementsByTagName('instrumentNames')   
        if rAr == 0:
            instNa[0].setAttribute('align','left')
        elif rAr == 2:
            instNa[0].setAttribute('align','right')
        else:
            if instNa[0].hasAttribute('align'):
                instNa[0].removeAttribute('align')
               
    return

def insertWavy(dos, nclx, nct, posHoch, posTief):           # Hilfslinien einsetzen
    global rLi
    action = 'Yes'
    
    if action == 'Yes':    
        do  = addNewElementNode(dos,'drawObj')
        if rLi == 0:
            ncl = addNewElementNode(do,'wavyLine')
        else:
            ncl = addNewElementNode(do,'line')
            ncl.setAttribute('lineWidth',"0.2")      
        ncl.setAttribute('x1',str(nclx+8.8))
        ncl.setAttribute('y1',str(posHoch))
        ncl.setAttribute('x2',str(nclx+5.9))
        ncl.setAttribute('y2',str(posTief))
    return

def insertStrich(dos, nclx, nct, pos, versatz):               # Hilfslinien einsetzen
    if pos >= 3:
        if str(pos)[-2:] == '.5': pos = pos-0.5
        while pos >= 3:
            do  = addNewElementNode(dos,'drawObj')
            ncl = addNewElementNode(do,'line')
            if versatz == '0':
                ncl.setAttribute('x1',str(nclx+4.4))
                ncl.setAttribute('y1',str(pos))
                ncl.setAttribute('x2',str(nclx+6.2))
                ncl.setAttribute('y2',str(pos))
            else:
                ncl.setAttribute('x1',str(nclx+8.3))
                ncl.setAttribute('y1',str(pos))
                ncl.setAttribute('x2',str(nclx+10.1))
                ncl.setAttribute('y2',str(pos))
            ncl.setAttribute('lineWidth',"0.2")
            pos = pos-1
    if pos <= -3:
        if str(pos)[-2:] == '.5': pos = pos+0.5
        while pos <= -3:
            do  = addNewElementNode(dos,'drawObj')
            ncl = addNewElementNode(do,'line')
            if versatz == '0':
                ncl.setAttribute('x1',str(nclx+4.4))
                ncl.setAttribute('y1',str(pos))
                ncl.setAttribute('x2',str(nclx+6.2))
                ncl.setAttribute('y2',str(pos))
            else:
                ncl.setAttribute('x1',str(nclx+8.3))
                ncl.setAttribute('y1',str(pos))
                ncl.setAttribute('x2',str(nclx+10.1))
                ncl.setAttribute('y2',str(pos))
            pos = pos+1
            ncl.setAttribute('lineWidth',"0.2")
    return

def insertNote(dos, nclx, nct, pos, vz, versatz):               # Note einsetzen

    global rKf
    
    vz = str(vz)
    do  = addNewElementNode(dos,'drawObj')
    ncl = addNewElementNode(do,'text')
    if versatz == '0':
        ncl.setAttribute('x',str(nclx+4.7))
    else:
        ncl.setAttribute('x',str(nclx+8.7))
    ncl.setAttribute('y',str(pos))
    nft = addNewElementNode(ncl,'font')                
    nft.setAttribute('face','capella3')
    nft.setAttribute('height','18')
    nft.setAttribute('weight','0')
    nft.setAttribute('charSet','2')
    nft.setAttribute('pitchAndFamily','0')
    nct = addNewElementNode(ncl,'content')

    if rKf == 0:
        tn = 'å'
    elif rKf == 1:
        tn = 'ñ'
    elif rKf == 2:
        tn = 'ò'
    elif rKf == 3:
        tn = 'ï'
    elif rKf == 4:
        tn = 'õ'

    textNode = doc.createTextNode(tn)
    nct.appendChild(textNode)
    if vz <> '0':
        #messageBox('VZ',str(vz))
        do  = addNewElementNode(dos,'drawObj')
        ncl = addNewElementNode(do,'text')
        if versatz == '0':
            ncl.setAttribute('x',str(nclx+3.2))
        else:
            ncl.setAttribute('x',str(nclx+7.2))
        ncl.setAttribute('y',str(pos))
        nft = addNewElementNode(ncl,'font')                
        nft.setAttribute('face','capella3')
        nft.setAttribute('height','18')
        nft.setAttribute('weight','0')
        nft.setAttribute('charSet','2')
        nft.setAttribute('pitchAndFamily','0')
        nct = addNewElementNode(ncl,'content')
        if vz == '1':
            vz = 'S'
        else:
            vz = 'Q' 
        #textNode = doc.createTextNode(latin1_d(vz))
        textNode = doc.createTextNode(vz)
        nct.appendChild(textNode)
    return

def getNotePos(pitch,clef):
    #messageBox('POS',str(pitch) + '\n' + str(clef))
    pOffset = dict(C='0', D='1', E='2', F='3', G='4', A='5', B='6')
    cOffset = dict(treble=0, G2P=3.5, G2M=-3.5, G1=1, alto=-3,
                   C1=-1, C2=-2,tenor=-4,C5=-5,bass=-6, F5=-7, F4M=-9.5, F4P =-2.5)
    if clef[2:3] == '+': clef = clef[0:2] + 'P'
    if clef[2:3] == '-': clef = clef[0:2] + 'M'
    pi = float(pOffset[pitch[0:1]])                     # pitch  offset
    ci = float(cOffset[clef])                           # clef   offset
    oi = float(pitch[1:3])                              # octave offset
    po = 20.5-(oi*3.5)-(pi*0.5)+ci
    return po

def getLayout(score,sy,st):
    sys      = score.getElementsByTagName('system')
    staff    = sys[sy].getElementsByTagName('staff')
    layout   = staff[st].getAttribute('layout')
    return layout

def changeDoc(score):

    global statusList, anzahlZeilen, syvon, shiftOK

# rWa=2 nur markierte Stimme noch codieren
    save   ={}
    start1 = 0
    shiftOK = 0
    stimmen = activeScore().voiceList()                     #Stimmenbezeichnungen merken
    for ix in range(len(stimmen)):
        save['sn' + str(ix)] = stimmen[ix]
        
    st = activeScore().system(0).nStaves()
    if st <> len(stimmen):
        #messageBox('Stimmumfang','Partitur Layout stimmt nicht mit erstem System überein.')
        return

    sel = curSelection()
    #messageBox('CURSOR',str(sel))
    selvon = sel[0]
    selbis = sel[1]
    if rWa == 0:
        syvon = 0
        sybis = int(activeScore().nSystems())-1
        stvon = selvon[1]
        stbis = selbis[1]
    else:
        syvon = selvon[0]
        sybis = selbis[0]
        stvon = selvon[1]
        stbis = selbis[1]
        if syvon >= sybis:
            syvon = selbis[0]
            sybis = selvon[0]
    
    #messageBox('CURSOR',str(syvon) + '\n' + str(sybis))
    
    System = activeScore().system(syvon)                        # Position des ersten Systems sichern
    for st in range(System.nStaves()):
        Staff  = System.staff(st)
        layout = getLayout(score,syvon,st)
        #layout = latin1_e(layout)
        save['ss' + str(layout)] = Staff
        #messageBox('staves',str('ss' + str(layout)))

    sy = syvon
    #messageBox('System',str(sy) + '\n' + str(selbis[0])) 
    while sy <= sybis:
        System = activeScore().system(sy)
        #messageBox('System',str(sy)) 
        for st in range(System.nStaves()):
            #messageBox('Staff',str(st)) 
            ctief  = 0
            choch  = 0
            dtief  = 0
            dhoch  = 0
            start = 0
            Staff  = System.staff(st)
            layout = getLayout(score,sy,st)
            found  = 0
            saved  = 0

            for vo in range(Staff.nVoices()):               # Umfang für jede Zeile in jedem System ermitteln
                #messageBox('Voice',str(vo)) 
                Voice = Staff.voice(vo)
                for no in range(Voice.nNoteObjs()):
                    NoteObj = Voice.noteObj(no)
                    if NoteObj.isChord():
                        found   = 1
                        for hd in range(NoteObj.nHeads()):
                            head = NoteObj.head(hd)
                            cpitch = head.chromaticPitch()
                            dpitch = head.diatonicPitch()
                            #messageBox('PITCH',str(no) +'\n' + str(cpitch) + '\n' + str(dpitch) + '\nStart=' + str(start) )
                            if cpitch > choch:
                                #messageBox('S1','S1')
                                choch = cpitch
                                dhoch = dpitch
                            if start == 0:
                                #messageBox('S2','S2')
                                ctief = cpitch
                                dtief = dpitch
                                start = 1
                            else:
                                if cpitch < ctief:
                                    #messageBox('S3','S3')
                                    ctief = cpitch
                                    dtief = dpitch
                            #messageBox('tiefhoch','SY=' + str(sy) + '\n' + str(ctief) + '  ***  ' + str(dtief) + '\n' + str(choch) + '  ***  ' + str(dhoch))

            if found == 1:
                #messageBox('FOUND',str(sy) + str(layout))
                #layout = latin1_e(layout)
                save['dt' + str(sy) + str(layout)] = dtief
                save['dh' + str(sy) + str(layout)] = dhoch
                save['syst']                       = sy
                #messageBox('TEIL',str(dhoch[0]) + '  ***  ' + str(dhoch[1]))
                if start1 == 0:
                    start  = 1
                    save['st' + str(layout)] = Staff
                found = 0
        sy = sy + 1
        
    ixsy = save['syst']+1
    #messageBox('STIMMEN',str(stimmen) + ' *** ' + str(ixsy) + '\n' + str(save))
    for w2 in range(len(stimmen)):                          # Umfang für jede Zeile ermitteln 
        dhoch = (0,0)
        dtief = (999,0)
        for w1 in range(ixsy):
            if 'dh' + str(w1) + str(stimmen[w2]) in save:
                Staff = save['st' + str(stimmen[w2])]
                hochg  = save['dh' + str(w1) + str(stimmen[w2])]
                tiefg  = save['dt' + str(w1) + str(stimmen[w2])]
                #messageBox('STIMMEN',str(hochg) + '\n' + str(tiefg))
                hoch  = int(hochg[0])
                hochK = int(hochg[1])
                tief  = int(tiefg[0])
                tiefK = int(tiefg[1])
                #messageBox('HochTIEF_G', str(dhoch) + '  ***  ' + str(dtief) + '\n' + str(hoch) + '  ***  ' + str(tief))
                #messageBox('TIEF',str(dtief[0]) + '      ' + str(dtief[1]))
                if dhoch[0] < hoch:
                    dhoch = hochg
                    
                if dtief[0] > tief:
                    dtief = tiefg
                elif dtief[0] == tief:
                    if dtief[1] == 0 and tiefK <> 0:
                        tiefg = (tiefg[0],0)
                    dtief = tiefg
      
                #messageBox('HochTIEF_S', str(dhoch) + '  ***  ' + str(dtief))
                save['tt' + str(stimmen[w2])] = dtief
                save['th' + str(stimmen[w2])] = dhoch


    if rWa <> 2:
        for w1 in range(len(stimmen)):                          # und einsetzen
            #messageBox('1',str(stimmen) + '\n' + str(save))
            found = 0
            if 'th' + str(stimmen[w1]) in save:
                hoch  = save['th' + str(stimmen[w1])]
                found = 1
            if 'tt' + str(stimmen[w1]) in save:
                tief  = save['tt' + str(stimmen[w1])]
                found = 1
            if 'st' + str(stimmen[w1]) in save:
                Staff = save['ss' + str(stimmen[w1])]
                found = 1
            if found == 1:
                if statusList[w1] == 1:
                    umfangEinsetzen(score, Staff, tief[0], hoch[0], tief[1], hoch[1], syvon, '0')
                else:
                    umfangEinsetzen(score, Staff, tief[0], hoch[0], tief[1], hoch[1], syvon, '1')
    return

def suDialog(score):
    global rWo,rLi,rAr,rKf,eEr,rWa,anzahlZeilen,statusList
    options = ScriptOptions() 
    opt = options.get()

    wo = '1'                # nach Schlüssel
    li = '0'                # wavy line
    ar = '0'                # Ausrichtung Instrumentenbezeichnung
    kf = '0'                # Kopfform
    er = '10'               # zusätzlicher Einzug
    wa = '0'                # Bereich
    
    if opt:
        wo = opt.get('DrWo',wo)
        li = opt.get('DrLi',li)
        ar = opt.get('DrAr',ar)
        kf = opt.get('DrKf',kf)
        er = opt.get('DrEr',er)
        wa = opt.get('DrWa',wa)

    statusList = []

    layout = score.getElementsByTagName('layout')
    staves = layout[0].getElementsByTagName('staves')
    sl = staves[0].getElementsByTagName('staffLayout')
    execString2 = 'subboxSt = VBox(['
    #execString3 = 'global '
    anzahlZeilen = sl.length
    for n in range(sl.length):        
        #stimme = latin1_e(sl[n].getAttribute('description'))
        stimme = sl[n].getAttribute('description')
        if n <> 0:
            execString2 = execString2 + ','
            
        execString1 = 'chkZeile' + str(n) + ' = CheckBox("' + str(stimme) + '",value=1)'                                                    
        exec(execString1)
        execString2 = execString2 + 'chkZeile' + str(n)
        
    execString2 = execString2 + '])' 
    exec(execString2)

    placeholder1   = Label('       ',width=1)
    radWa      = Radio([tr('score'),tr('systems')],text=tr('establish'),value=int(opt.get('rWa',str(wa))))
    radWo      = Radio([tr('staffBegin'),tr('afterClef'),tr('beforeTimeAllKey'),tr('beforeTime1KeyC'),tr('beforeSystem')],text=tr('insVoiceRange'),value=int(opt.get('rWo',str(wo))))
    radLi      = Radio([tr('wavyLine'),tr('line')],text=tr('connectLine'),value=int(opt.get('rLi',str(li))))
    radAr      = Radio([tr('alignLeft'),tr('alignCentered'),tr('alignRight')],text=tr('instrDesign'),value=int(opt.get('rAr',str(ar))))
    radKf      = Radio([tr('normal'),tr('rombus'),tr('cross'),tr('triangle'),tr('square')],text=tr('head'),value=int(opt.get('rKf',str(kf))))
    lablEr     = Label(tr('exRecess'),width=6)
    editEr     = Edit(opt.get('eEr',str(er)),width=4)
    lab2Er     = Label(tr('slg'))
    subboxKf   = HBox([radKf],padding=4)
    subboxWa   = HBox([radWa,subboxSt],padding=4)
    subboxWo   = VBox([radWo,subboxKf],padding=4)
    subboxZe   = HBox([lablEr,editEr,lab2Er])
    subboxIb   = VBox([radAr,subboxZe])
    subboxVo   = HBox([radLi,subboxIb],text=tr('addPar'))
    text1      = Label(tr('warning1'),width=10)
    text2      = Label(tr('warning2'),width=10)
    text3      = Label(tr('warning3'),width=10)
    text4      = Label(tr('warning4'),width=10)
    text5      = Label(tr('warning5'),width=10)
    box  = VBox([subboxWa,subboxWo,subboxVo,text1,text2,text3,text4,text5,placeholder1],padding=1)
    dlg  = Dialog(tr('title') + version, box, help=tr('info'))
 
    if dlg.run():
        rWo = radWo.value()
        rLi = radLi.value()
        rAr = radAr.value()
        rKf = radKf.value()
        eEr = editEr.value()
        rWa = radWa.value()
        wo  = opt.get('DrWo','')
        li  = opt.get('DrLi','')
        ar  = opt.get('DrAr','')
        kf  = opt.get('DrKf','')
        er  = opt.get('DrEr','')
        wa  = opt.get('DrWa','')
        opt = dict(DrWo = str(rWo),
                   DrLi = str(rLi),
                   DrAr = str(rAr),
                   DrKf = str(rKf),
                   DrEr = str(eEr),
                   DrWa = str(rWa)
                   )
        options.set(opt)

        for n in range(anzahlZeilen):
                execString = "v = chkZeile" + str(n) + ".value()"
                exec(execString)
                statusList.append(v)
        return True
    else:
        return False
    
# Hauptprogramm:

from caplib.capDOM import ScoreChange
import tempfile

activeScore().registerUndo("Stimmumfang")

class ScoreChange(ScoreChange):
    
    def changeScore(self, score):
        if suDialog(score):
            changeDoc(score)                          

if activeScore():

    global tempInput, tempOutput
    tempInput = tempfile.mktemp('.capx')
    tempOutput = tempfile.mktemp('.capx')
    activeScore().write(tempInput)

    ScoreChange(tempInput, tempOutput)
    
    activeScore().read(tempOutput)
    os.remove(tempInput)
    os.remove(tempOutput)