# -*- coding: ISO-8859-1 -*-
""" capellaScript -- (c) Peter Becker
>>> Triolen Manager

    Mit diesem Script lassen sich n-tolen Klammern entfernen,|
    oder die Richtung der Klammer umdrehen
    
<<<
<?xml version="1.0" encoding="ISO-8859-1"?>
<info>
  <lang id="en">
    <title>Tuplet Manager</title>
    <descr>
      <p>With this scipt tuplet brackets can be removed,
or the direction of tuplet brackets can be changed.
</p>
    </descr>
  </lang>

  <lang id="de">
    <title>Triolen Manager</title>
    <descr>
      <p>Mit diesem Script lassen sich n-tolen Klammern entfernen,
oder die Richtung der Klammer umdrehen
</p>
    </descr>
  </lang>

  <lang id="nl">
    <title>Triolenmanager</title>
    <descr>
      <p>Met dit script kunnen n-tolen-haken worden verwijderd,
of de richting van de haken worden omgedraaid.
</p>
    </descr>
  </lang>
</info>

History:  25.09.07 - V 1.0.0 Erste Ausgabe
          29.01.11 - V 1.0.1 Richtungsänderung der Klammer, Bereichsunterstützung
          31.01.11 - V 1 0.2 zusätzlicher Versatz und waagerechte Klammern
          23.05.12 - V 1.0.3 Anpassung an Capella 7.x Verhalten. noAdjust=true
          25.06.12 - V 1.1.0 bessere Positionierung bei geraden Klammern, Klammerbreite
          06.08.12 - V 1.2.0 gelöschte Klammern rekonstruieren
          15.11.14 - V 1.2.1 neue Option Klammer hinzufügen
          21.08.17 - V 1.2.2 Anpassung an Capella 8
          16.10.17 - V 1.2.3 Internationalisierung (en-de-nl) (WW) 
          26.01.23 - V 1.2.5 Klammerfrarbe hellgrau/grau/schwarz
"""
english = {
    'delBracket'        :'delete brackets',
    'rotateBracket'     :'rotate brackets',
    'keepBracket'       :'keep brackets here',
    'reconDelBracket'   :'reconstruct deleted brackets',
    'addBracket'        :'add brackets',
    'function'          :'Function',
    'score'             :'whole score',
    'markSyst'          :'marked systems',
    'markRangeStaff'    :'marked range in a staff',
    'range'             :'Range',
    'unchanged'         :'unchanged',
    'tuplBracket'       :'tuplet bracket',
    'form'              :'Form',
    'xtrDist'           :'Extra distance',
    'xs'                :'very small',
    'sm'                :'small',
    'nor'               :'normal',
    'lar'               :'large',
    'xl'                :'very large',
    'bracketwidth'       :'Bracket width',
    'indic1'            :'After "reconstructing brackets" call up unconditionally the Capella Funktion "Adjust graphic objects',
    'indic2'            :'to the notes" and after that possibly once make use of the Tuplet Manager for further formating.',
    'bracket'           :'Brackets',
    'title'             :'Tuplet Manager   Version: ',
    'gray'              :'gray',
    'black'             :'black',
    'lightgray'         :'lightgray', 
    'color'             :'color'
}
german = {
    'delBracket'        :'Klammer weg',
    'rotateBracket'     :'Klammer spiegeln',
    'keepBracket'       :'Klammer hier beibehalten',
    'reconDelBracket'   :'gelöschte Klammer rekonstruieren',
    'addBracket'        :'Klammer hinzufügen',
    'function'          :'Funktion',
    'score'             :'ganze Partitur',
    'markSyst'          :'markierte Systeme',
    'markRangeStaff'    :'markierter Bereich in einer Zeile',
    'range'             :'Bereich',
    'unchanged'         :'unverändert',
    'tuplBracket'       :'gerade Klammer',
    'form'              :'Form',
    'xtrDist'           :'zusätzlicher Abstand',
    'xs'                :'sehr eng',
    'sm'                :'eng',
    'nor'               :'normal',
    'lar'               :'weit',
    'xl'                :'sehr weit',
    'bracketwidth'      :'Klammerbreite',
    'indic1'            :'Nach "Klammer rekonstruieren" unbedingt die Capella Funktion "Grafikobjekte an Noten anpassen"',
    'indic2'            :'aufrufen und danach eventuell noch einmal den Triolenmanager für weitere Formatierungen benutzen.',
    'bracket'           :'Klammer',
    'title'             :'Triolen - (n-Tolen) Manager   Version: ',
    'gray'              :'grau',
    'black'             :'schwarz',
    'lightgray'         :'hellgrau',
    'color'             :'Farbe'
}
dutch = {
    'delBracket'        :'haken verwijderen',
    'rotateBracket'     :'haken spiegelen',
    'keepBracket'       :'haken hier laten staan',
    'reconDelBracket'   :'verwijderde haken reconstrueren',
    'addBracket'        :'haken toevoegen',
    'function'          :'Functie',
    'score'             :'gehele partituur',
    'markSyst'          :'gemarkeerde systemen',
    'markRangeStaff'    :'gemarkeerd gebied in een notenbalk',
    'range'             :'Bereik',
    'unchanged'         :'onveranderd',
    'tuplBracket'       :'rechthoekige haak',
    'form'              :'Vorm',
    'xtrDist'           :'Extra afstand',
    'xs'                :'zeer smal',
    'sm'                :'smal',
    'nor'               :'normaal',
    'lar'               :'breed',
    'xl'                :'zeer breed',
    'bracketwidth'      :'Breedte haak',
    'indic1'            :'Na "haken reconstrueren" altijd de capella functie "grafische objecten aan de noten aanpassen"',
    'indic2'            :'oproepen en daarna eventueel nog een keer de Triolenmanager gebruiken voor verdere aanpassingen.',
    'bracket'           :'Haken',
    'title'             :'Triolen - (n-tolen) manager   Versie: ',
    'gray'              :'grijs',
    'black'             :'zwart',
    'lightgray'         :'lichtgrijs',
    'color'             :'kleur'
}

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

#-----------------------------------------

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

version = '1.2.5'

counter = 0
doc     = [] # parentNode von score

def insertElementNode(el,ref,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.insertBefore(newChild,ref)
    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 reconstructBracket(note):

    global counter

    duration = note.getElementsByTagName('duration')
    bracket  = note.getElementsByTagName('bracket')
    heads    = note.getElementsByTagName('heads')

    if duration: 
        tuplet   = duration[0].getElementsByTagName('tuplet')
        if tuplet:
            if tuplet[0].hasAttribute('count'):
                count = tuplet[0].getAttribute('count')
                counter = counter + 1
                if counter == 1:
                    if bracket.length == 0: 
                         noteRange = int(count)-1
                         dOs     = insertElementNode(note,heads[0],'drawObjects')
                         dO      = addElementNode(dOs,'drawObj')
                         bracket = addElementNode(dO,'bracket')
                         basic   = addElementNode(dO,'basic')
                         bracket.setAttribute('X1','0')
                         bracket.setAttribute('X2','1')
                         bracket.setAttribute('Y1','-3.5')
                         bracket.setAttribute('Y2','-3.5')
                         bracket.setAttribute('orientation','up')
                         bracket.setAttribute('number',str(count))
                         basic.setAttribute('noteRange',str(noteRange))
                         #messageBox('Ausgabe',str(dOs) + '\n' + str(dO) + '\n' + str(bracket)  + '\n' + str(basic) + '\n' + str(note))
                if int(count) == int(counter):
                    count = counter = 0       
            else:
                count = counter = 0

def handleBracket(note):

    global pos, ber, form, abst, weit, color
    
    dOs = note.getElementsByTagName('bracket')
    x_abst       = 2
    y_offsetList = (-1.5,-1,-0.5,0,0.5,1,1.5)
    x_offsetList = (-1,-0.5,0,0.5,1)
    y_offset     = y_offsetList[abst] + 0.1
    x_offset     = x_offsetList[weit]
    
    stemDir1     = 'auto'
    
    dOs = note.getElementsByTagName('bracket')
    
    for do in range(dOs.length):
        bracket = dOs[do]
        
        voice = bracket.parentNode.parentNode.parentNode.parentNode.parentNode                      # -> stemDir wird noch nicht unterstützt
        if voice.hasAttribute('stemDir'):                                                           # stemDir auf oberer (voice) Ebene
            stemDir1 = voice.getAttribute('stemDir')
        stem1_chord_List = bracket.parentNode.parentNode.parentNode.getElementsByTagName('stem')    # stemDir auf unterster (chord) Ebene
        for st in range(stem1_chord_List.length):
            stem1 = stem1_chord_List[st]
            if stem1.hasAttribute('dir'):
                stemDir1 = stem1.getAttribute('dir')
        if stemDir1 == 'auto':                                                                      #stemDir wie im Stimmformat festgelegt 
            a=1                                                                                     # coding 2b done
        
        #messageBox('stemDir1', str(stemDir1))
        
        bas = bracket.parentNode.getElementsByTagName('basic')
        bas[0].setAttribute('noAdjust','true')
        y1      = float(bracket.getAttribute('y1'))
        y2      = float(bracket.getAttribute('y2'))
        x1      = float(bracket.getAttribute('x1'))
        x2      = float(bracket.getAttribute('x2'))
        oDir    = bracket.getAttribute('orientation')
        #messageBox('X1',str(x1))

        x1 = x1 - x_offset                                    # Klammerbreite einstellen
        x2 = x2 + x_offset

        if form == 1:                                         # gerade richten
            y1 = float(y1)
            y2 = float(y2)
            #messageBox('form1',str(y1) + "  " + str(y2))
            if y1 < y2:
                y2 = y1 
            else:
                y1 = y2
            #messageBox('form2',str(y1) + "  " + str(y2))
            if y1 >= 0:
                if y1 <= 3.0:
                        y1 = y2 = 3.8 + y_offset
            else:
                if y1 >= -3.0:
                        y1 = y2 = -3.8 - y_offset
            if y1 >= 0:
                y1 = y2 = y1 + y_offset
            else:
                y1 = y2 = y1 - y_offset
        
        
        if color == 0:
            bracket.setAttribute('color','000000')
        elif color == 1:
            bracket.setAttribute('color','AAAA7F')
        else:    
            bracket.setAttribute('color','F0F0F0')

        if bracket.hasAttribute('orientation'):
            if pos == 1 and form == 0:                        # spiegeln, ansonsten unverändert
                if oDir == 'up':
                    y1 = float(y1) + 8.5 + y_offset
                    y2 = float(y2) + 8.5 + y_offset
                    dir = 'down'
                else:
                    y_offset = y_offset * -1
                    y1 = float(y1) - 8.5 + y_offset
                    y2 = float(y2) - 8.5 + y_offset
                    dir = 'up'
                if pos == 1:
                    bracket.setAttribute('orientation',dir)
                    
            elif pos == 1 and form == 1:                      # spiegeln, gerade Klammer, hier fehlt noch die Einbeziehung der Tonhöhe
                #messageBox('up',str(y1))
                if oDir == 'up':
                    y1 = float(y1) + 8.5
                    y2 = float(y2) + 8.5
                    dir = 'down'
                else:
                    y1 = float(y1) - 8.5
                    y2 = float(y2) - 8.5
                    dir = 'up'

                if pos == 1:
                    bracket.setAttribute('orientation',dir)
                    
            elif pos == 2:                                    # nur offset
                if oDir == 'up':
                    y_offset = y_offset * -1

                y1 = float(y1) + y_offset
                y2 = float(y2) + y_offset
             
            elif pos == 0:                                    # ohne Klammer
                bracket.removeAttribute('orientation')
        else:        
            if pos == 4:
                bracket.setAttribute('orientation','up')
                
        #messageBox('X2',str(x1))        
        bracket.setAttribute('y1',str(y1))
        bracket.setAttribute('y2',str(y2))
        bracket.setAttribute('x1',str(x1))
        bracket.setAttribute('x2',str(x2))
            
                
def getElementObjects(objList):  # returns a List
    newList = NodeList()
    for n in range(objList.length):
        if objList[n].nodeType == objList[n].ELEMENT_NODE:
            newList.append(objList[n])
    return newList

def changeDoc(score):
    
    global pos, ber, form, abst

    sel = curSelection()
    #messageBox('SEL',str(sel))
    selvon = sel[0]
    selbis = sel[1]

    syvon = selvon[0]
    stvon = selvon[1]
    vovon = selvon[2]
    novon = selvon[3]
    sybis = selbis[0]
    stbis = selbis[1]
    vobis = selbis[2]
    nobis = selbis[3]

    systems   = score.getElementsByTagName('system')
    staff     = systems[syvon].getElementsByTagName('staff')
    voice     = staff[stvon].getElementsByTagName('voice')
    noteObjs  = voice[vovon].getElementsByTagName('noteObjects')[0]
    objList   = getElementObjects(noteObjs.childNodes) 

    if ber == 0:                                                                #ganze Partitur bearbeiten
        for sys in range(systems.length):
            noteObjs = systems[sys].getElementsByTagName('noteObjects')
            for nos in range(noteObjs.length):
                noteObj = noteObjs[nos]
                objList   = getElementObjects(noteObj.childNodes)
                for no in range(objList.length):
                    obj = objList[no]
                    if pos <> 3:
                        handleBracket(obj)
                    else:
                        reconstructBracket(obj)
    elif ber == 1:                                                              #markierte Systeme bearbeiten
        if syvon >= sybis:
            syixEnde  = syvon + 1
            syixStart = sybis  
        else:
            syixEnde  = sybis + 1
            syixStart = syvon
        while syixStart < syixEnde:
            noteObjs = systems[syixStart].getElementsByTagName('noteObjects')
            syixStart = syixStart + 1
            for nos in range(noteObjs.length):
                noteObj = noteObjs[nos]
                objList   = getElementObjects(noteObj.childNodes)
                for no in range(objList.length):
                    obj = objList[no]
                    if pos <> 3:
                        handleBracket(obj)
                    else:
                        reconstructBracket(obj)
    else:                                                                       #markierten Bereich in der Zeile bearbeiten     
        if novon >= nobis:
            ixEnde  = novon
            ixStart = nobis  
        else:
            ixEnde  = nobis
            ixStart = novon
        while ixStart < ixEnde:
            obj = objList[ixStart]
            if pos <> 3:
                handleBracket(obj)
            else:
                reconstructBracket(obj)
            ixStart = ixStart + 1


def pqDialog():
    global pos, ber, form, abst, weit, color

    options = ScriptOptions() 
    opt = options.get()

    Aopt      = [tr('delBracket'),tr('rotateBracket'),tr('keepBracket'),tr('reconDelBracket'),tr('addBracket')]
    radioA    = Radio(Aopt, value=int(opt.get('pos', 0)),text=tr('function'))
    Bopt      = [tr('score'),tr('markSyst'),tr('markRangeStaff')]
    radioB    = Radio(Bopt, value=int(opt.get('ber', 0)),text=tr('range'))
    Copt      = [tr('unchanged'),tr('tuplBracket')]
    radioC    = Radio(Copt, value=int(opt.get('form', 0)),text=tr('form'))
    Eopt      = [tr('black'),tr('gray'),tr('lightgray')]
    radioE    = Radio(Eopt, value=int(opt.get('color', 0)),text=tr('color'))
    Dopt      = ['-1,5','-1','-0,5','0                      ','+0,5','+1','+1,5']
    radioD    = Radio(Dopt, value=int(opt.get('abst', 3)),text=tr('xtrDist'))
    Fopt      = [tr('xs'),tr('sm'),tr('nor'),tr('lar'),tr('xl')]
    radioF    = Radio(Fopt, value=int(opt.get('weit', 2)),text=tr('bracketwidth'))
    Anmerk1   = Label(tr('indic1'))
    Anmerk2   = Label(tr('indic2'))
    subbox0   = VBox([radioC,radioE],padding=4)
    subbox1   = HBox([radioA,radioB],padding=4)
    subbox2   = HBox([subbox0,radioD,radioF],padding=4,text=tr('bracket'))
    box       = VBox([subbox1,Anmerk1,Anmerk2,Label(" "),subbox2],padding=4)
    
    dlg = Dialog(tr('title') + version, box)
    if dlg.run():
        pos   = radioA.value()
        ber   = radioB.value()
        form  = radioC.value()
        abst  = radioD.value()
        weit  = radioF.value()
        color = radioE.value()

        opt.update(dict(pos=pos, ber=ber, form=form, abst=abst, weit=weit, color=color))
        options.set(opt)
        return True
    else:
        return False
            
# Hauptprogramm:

from caplib.capDOM import ScoreChange
import tempfile

class ScoreChange(ScoreChange):
    def changeScore(self, score):
        global doc
        doc = score.parentNode
        changeDoc(score)

if pqDialog():
    if activeScore():
        activeScore().registerUndo('Triolen Manager')
        tempInput = tempfile.mktemp('.capx')
        tempOutput = tempfile.mktemp('.capx')
        activeScore().write(tempInput)
    
        ScoreChange(tempInput, tempOutput)

        activeScore().read(tempOutput)
        #messageBox('TEMP',str(tempOutput))
        os.remove(tempInput)
        os.remove(tempOutput)