# -*- coding: ISO-8859-1 -*-
""" capellaScript -- Copyright (c) 2004 Hartmut Ring, 2013/2021 Peter Becker
>>> Taktnummern : Taktnummerierung in wählbaren Abständen
    Abstände, Form und Lage der Taktnummerierung
    werden in einem Dialog erfragt.||
    
    Für automatische Taktnummern am Anfang jedes Systems
    verwenden Sie bitte die in capella eingebaute Funktion
    (Menü: Extras -- Taktnummerierung)
<<<

<?xml version="1.0" encoding="ISO-8859-1"?>
<info>
  <lang id="en">
    <title>Bar Numbers</title>
    <descr>
      <p>Distances, form and position of bar numbers can be set in a
dialogue.
    
Please make use of the function of bar numbering that is
included in capella for automatic bar numbers at the outset of all
systems (menu: Extra --> Bar numbering).</p>
    </descr>
  </lang>

  <lang id="de">
    <title>Taktnummern</title>
    <descr>
      <p>Abstände, Form und Lage der Taktnummerierung
werden in einem Dialog erfragt.
    
Für automatische Taktnummern am Anfang jedes Systems
verwenden Sie bitte die in capella eingebaute Funktion
(Menü: Extras -- Taktnummerierung)</p>
    </descr>
  </lang>

  <lang id="nl">
    <title>Maatnummers</title>
    <descr>
      <p>Afstanden, vorm en positie van de maatnummering kunnen
in een dialoogvenster worden ingesteld.

Automatische maatnummers aan het begin van ieder systeem
kunnen worden ingesteld door de in capella ingebouwde functie
(Menu: Extra --> Maatnummering)</p>
    </descr>
  </lang>
</info>


Anpassungen von Paul Villiger
14.05.05 - BarCount implementiert. Die Korrektur der automatischen Taktnummerierung wird berücksichtigt. 
Anpassung von Peter Becker
07.06.05 - Setzen von Taktnummern an der Cursorposition
13.06.05 - Bugfix
Anpassungen von Paul Villiger
30.06.05 - Bugfix: Cursor innerhalb eines Taktes funktioniert
         - Bugfix: Cursor am Zeilenende führt nicht zu Absturz
Anpassung Peter Becker
16.09.13 - Unterstützung für Capella ab V7 wählbar, x-Position setzen, Option: alle Taktnummern löschen
Anpassungen Wilfred van de Wal
19.08.17 - Internationalisierung (en-de-nl);
         - vertikale Lage um 1/2 slg erhöht und Größe um 1 Pkt erhöht damit näher bei Einstellung in capella (gemerkt: ##(WW))
Anpassung Peter Becker
30.11.21 - Taktnummern mit "behindNotes" versehen um bei Capella 9 nicht in Konflikt mit Texten ( Liedtext ) über der Zeile zu kommen
           behindNotes im Menü auswählbar
10.06.23 - Schriftart, Schnitt und Fett wählbar  
11.06.23 - Bugfix. Es wurde nur rechteckig umrandet
27.11.23 - Range erweitert
19.03.24 - Positionierung verbessert

"""
version = '27.11.2024'

english = {
    'beforeCap7'    :'before capella version 7',
    'fromCap7'      :'from capella version 7',
    'method'        :'Method',
    'allBy'         :'at all &by',
    'divisibleBars' :'divisible bars (0 = a separate bar number at the cursor)',
    'horPos'        :'&Horizontal position',
    'hor'           :'Horizontal',
    'gap'           :'slg.',
    'vertPos'       :'&Vertical position',
    'vert'          :'Vertical',
    'gap2'          :'0 and positive above , negativ below',
    'pos'           :'Position',
    'size'          :'&Size',
    'pt'            :'Point',
    'sansSerif'     :'sans serif',
    'color'         :'Color',
    'black'         :'black',
    'red'           :'red',
    'blue'          :'blue',
    'green'         :'green',
    'font'          :'Font',
    'no'            :'&none',
    'rectang'       :'&rectangular',
    'oval'          :'&oval',
    'frame'         :'Frame',
    'delExtNum'     :'Delete extant bar numbers',
    'setNum'        :'Set bar numbers',
    'remAllNum'     :'remove all bar numbers',
    'delNum'        :'Delete bar numbers',
    'barNum'        :'Bar Numbering',
    'behNo'         :'behind notes',
    'kursiv'        :'italic',
    'fett'          :'bold',
    'Schriftart'    :'Font'
}
german = {
    'beforeCap7'    :'vor Capella Version 7',
    'fromCap7'      :'ab Capella Version 7',
    'method'        :'Methode',
    'allBy'         :'bei alle &durch',
    'divisibleBars' :'teilbaren Takte (0 = eine einzelne Taktnummer beim Cursor)',
    'horPos'        :'&Horizontale Lage',
    'hor'           :'Horizontal',
    'gap'           :'Zw.',
    'vertPos'       :'&Vertikale Lage',
    'vert'          :'Vertikal',
    'gap2'          :'0 und positiv oben, negativ unten',
    'pos'           :'Lage',
    'size'          :'&Größe',
    'pt'            :'Punkt',
    'sansSerif'     :'ohne Serifen',
    'color'         :'Farbe',
    'black'         :'schwarz',
    'red'           :'rot',
    'blue'          :'blau',
    'green'         :'grün',
    'font'          :'Schrift',
    'no'            :'kei&ner',
    'rectang'       :'&rechteckig',
    'oval'          :'&oval',
    'frame'         :'Rahmen',
    'delExtNum'     :'vorhandene Taktnummern entfernen',
    'setNum'        :'Taktnummern setzen',
    'remAllNum'     :'alle Taktnummern entfernen',
    'delNum'        :'Taktnummern löschen',
    'barNum'        :'Taktnummerierung',
    'behNo'         :'hinter den Noten',
    'kursiv'        :'kursiv',
    'fett'          :'fett',
    'Schriftart'    :'Schriftart'
}
dutch = {
    'beforeCap7'    :'vóór Capella versie 7',
    'fromCap7'      :'vanaf Capella versie 7',
    'method'        :'Methode',
    'allBy'         :'bij alle &door',
    'divisibleBars' :'deelbare maten (0 = één enkel maatnummer bij de cursor)',
    'horPos'        :'&Horizontale positie',
    'hor'           :'Horizontaal',
    'gap'           :'tu.',
    'vertPos'       :'&Verticale positie',
    'vert'          :'Verticaal',
    'gap2'          :'0 en positief boven de streep, negatief onder der lijn',
    'pos'           :'Positie',
    'size'          :'&Grootte',
    'pt'            :'Punt',
    'sansSerif'     :'schreefloos',
    'color'         :'Kleur',
    'black'         :'zwart',
    'red'           :'rood',
    'blue'          :'blauw',
    'green'         :'groen',
    'font'          :'Lettertype',
    'no'            :'gee&n',
    'rectang'       :'&rechthoekig',
    'oval'          :'&ovaal',
    'frame'         :'Kader',
    'delExtNum'     :'reeds aanwezige maatnummers verwijderen',
    'setNum'        :'Maatnummers plaatsen',
    'remAllNum'     :'alle maatnummers verwijderen',
    'delNum'        :'Maatnummers wissen',
    'barNum'        :'Maatnummering',
    'behNo'         :'achter de noten',
    'kursiv'        :'cursief',
    'fett'          :'stoer type'    ,
    'Schriftart'    :'lettertype'
    }

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


#----------------------------------------------------------------------------
cs = curSelection()[0]                       # Cursor Position als Index
co  = cursorObj()                            # NoteObj nach Cursor
t = dict(type = 'rectangle', x1 = 0, y1 = 0, x2 = 0, y2 = 0,
        lineWidth = 0.3)
t['tag'] = '2086-50' 

if co <> 0 and (co.isChord() or co.isRest()): # nur markieren wenn Note oder Pause
    co.addDrawObj(t)                         # NoteObj markieren

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

barNumTag = '0-1'
global Sfett, Skursiv

colors     = [Color.black, Color.red, Color.blue, Color.green]
colorNames = [tr('black'), tr('red'), tr('blue'), tr('green')]

def markBar(obj, n, xBar, x, y, color, size, colorF, form, Sfett, Skursiv, tfnt, tfnt1):
    #messageBox('X',str(x))
    #messageBox('TEST1', str(Sfett) + ' *** ' + str(Skursiv))
    x = int(x)
    dx = obj.posX() - xBar - x 
    Breite = (1.2 + 1.3 * len(str(n))) * size/11.0
    if ver == 0:
        cont = str(n)                                           # vor Capella Vers. 7 
    else:
        cont = '$(|)'                                           # ab Capella Vers.7
    y = y+7.5
    #messageBox('y', str(y) + '**' + str(size))
    if y > 0:
        #messageBox('y1', str(y) + '**' + str(size))             # nach unten
        y = y+3.4
    elif y <= 0:                                                # nach oben
        #messageBox('y2', str(y) + '**' + str(size))
        y = y-3 
        
    txt = dict(
        type = 'text',
        x = Breite/2-dx,
        y = y + size/22.0,
        content = cont,
        align = 'center',
        font = dict(height=size, color=colors[colorF])
        )
    
    if Sfett == int(1):
        txt['font']['weight'] = 700    
    txt['font']['italic'] = int(Skursiv)
    
    #messageBox('BN',str(behindNo.value()))
    #if sansSerif:
    #    txt['font']['face'] = 'Arial'
    
    txt['font']['face'] = tfnt1

    if form == 0:
        txt['x'] -= size/11.0
        txt['tag'] = barNumTag
        txt['behindNotes'] = behindNo.value()
        obj.addDrawObj(txt)
    else:
        frame = dict(
            type = 'rectangle',
            x1 = -dx,       y1 = y-1.75*(size/11.0),
            x2 = Breite-dx, y2 = y+1*(size/11.0),
            lineColor = colors[color],
            fillColor = Color.white)
        if form == 2:
            frame['type'] = 'ellipse'
        group = dict(
            type  = 'group',
            items = [frame, txt], #, wmf],
            tag   = barNumTag,
            behindNotes = behindNo.value()
            )
        obj.addDrawObj(group)

def getUpbeat(staff):
    """ ermittelt, ob die Notenzeile mit einem Auftakt beginnt.
        Ausschlaggebend ist dabei die erste Stimme.
    """
    time = 0
    tFirstBar = staff.defaultMeter()
    for obj in staff.voice(0).noteObjs():
        if time == 0:
            if obj.subType() == NoteObj.METER:
                tFirstBar = obj.meter()
        else:
            if obj.subType() in (NoteObj.METER, NoteObj.KEY, NoteObj.EXPL_BARLINE):
                return (time < tFirstBar)
            elif obj.implBarline() != 0:
                return False
        time += obj.duration()
    return False

def markBars(staff, cond, x, y, color, size, colorF, form, start=1):
    """ markiert alle Takte, deren Nummern das Prädikat cond erfüllen
        und liefert die Nummer des ersten Taktes des nächsten  Systems zurück
    """
    voice = staff.voice(0)          # an erster Stimme orientieren
    tFirstBar = staff.defaultMeter()
    tLastBar = 0
    n = start
    xBar = 0
    upbeat = getUpbeat(staff)
    if upbeat:
        xBar = -1  # ersten Takt nicht zählen
    time = 0
    setSingle = False
    for obj in voice.noteObjs():
        #------------------------------------------------------------------------------       
        if step == 0:
            if xBar >= 0:
                sav_xBar = xBar                 # Taktstrich Position sichern
            for i in range(obj.nDrawObjs()):   # einzelne Taktnummer ausgeben
                d = obj.drawObj(i)
                if d.has_key('tag')and d['tag'] == '2086-50':
                    # markBar(obj, n, xBar, x, y, color, size, colorF, sansSerif, form)
                    obj.deleteDrawObj(i)
                    xBar = sav_xBar
                    setSingle = True
        #------------------------------------------------------------------------------        
 
        #--- Taknummer an nächster Note oder Pause verankern ---
        if xBar >= 0 and (obj.isChord() or obj.isRest()):
            if cond(n) or setSingle:
                markBar(obj, n, xBar, x, y, color, size, colorF, form, Sfett, Skursiv, tfnt, tfnt1)
                setSingle = False
            xBar = -1   
        if obj.isRest():
            #if obj.fullMeasures():
            #    n += obj.duration() - 1
            if obj.fullMeasures() > 0:
                n += obj.fullMeasures() - 1
                upbeat = False
        if obj.subType() in (NoteObj.METER, NoteObj.KEY, NoteObj.EXPL_BARLINE):
            if time == 0 and obj.subType() == NoteObj.METER:
                tFirstBar = obj.meter()
            if time > tLastBar:
                tLastBar = time
                if time >= tFirstBar:
                    if not upbeat:
                        n += 1
                xBar = obj.posX()
            if time != 0:
                upbeat = False
        if obj.implBarline() != 0:
            upbeat = False
            n += 1
            xBar = obj.implBarline().posX()

        time += obj.duration()
    return n

options = ScriptOptions() 
opt = options.get()
#messageBox('DEF',str(int(opt.get('x', '4'))))
#----------------------------------------------------
#----- Dialogaufbau ---------------------------------
#
#----------------------------------------------------
# Gruppe: Version
# 
radVer = Radio([tr('beforeCap7'),tr('fromCap7')],
               value=int(opt.get('CapVersion', '1')))
hBox0  = HBox([radVer],text=tr('method'),padding=8)
#----------------------------------------------------
# Gruppe: Taktnummern setzen
# 
# alle durch ... teilbaren Takte
edit1  = Edit(opt.get('step', '5'), min=0, max=50, width=4)
hBox1  = HBox([Label(tr('allBy')), edit1,
               Label (tr('divisibleBars'))],
               padding=8)
#----------------------------------------------------
#Horizontale Lage 
comboX = ComboBox(['-3','-2','-1','0','1','2','3'],
                  value=int(opt.get('x', '3')))
hBox2  = HBox([Label(tr('horPos')), comboX,
               Label(tr('gap'))], text=tr('hor'), padding=8)

#----------------------------------------------------
#Vertikale Lage ... /2 Zw. über Mittellinie 
comboY = ComboBox([str(i) for i in range(-30,31)],  ##(PB) Range erweitert     
                  value=int(opt.get('y', '10'))+15) ##(WW) +15 war +16    
hBox3  = HBox([Label(tr('vertPos')), comboY,
              Label(tr('gap2'))], text=tr('vert'), padding=8)

#----------------------------------------------------
#Horizontale Lage 
behindNo = CheckBox(tr('behNo'), value=int(opt.get('behNo', '0')))
#hBox2a = HBox([Label(tr('behNo')), behindNo],padding=8)

#----------------------------------------------------
#Subgruppe Lage
hBox4a = HBox([hBox2, hBox3])
hBox4  = VBox([hBox4a, behindNo],text=tr('pos'),padding=8)

#----------------------------------------------------
# Gruppe: Schrift
# Größe ... Punkt
comboSize = ComboBox([str(i) for i in range(6,15)],
                     value=int(opt.get('size', '11'))-5)##(WW) -5 war -6
hBox5  = HBox([Label(tr('size')), comboSize, Label(tr('pt'), width=10)], padding=8)

# Font
#checkS = CheckBox(tr('sansSerif'), value=int(opt.get('sansSerif', '0')))

FontList = ['Arial','TimesNewRoman','Calibri','Courier New']
lablFont = Label(tr('Schriftart'))
comFont  = ComboBox(FontList,width=18,value=int(opt.get('tfnt','0')))
sbFont   = HBox([lablFont,comFont],width=20) 

# Farbe ...
comboColorF = ComboBox(colorNames, width=8, value=int(opt.get('clrF', '0')))
hBoxF  = HBox([Label(tr('color')),  comboColorF], padding=16)

# kursiv
checkK = CheckBox((tr('kursiv')), value=int(opt.get('Skursiv', '0')))

# fett
checkF = CheckBox((tr('fett')), value=int(opt.get('Sfett', '0')))     

# Gruppe Schrift zusammensetzen:
vBoxF  = VBox([hBox5, sbFont, hBoxF, checkK, checkF], text=tr('font'), padding=8)

#----------------------------------------------------
# Gruppe: Rahmen
# Radiobuttons
radio  = Radio([tr('no'),tr('rectang'),tr('oval')],
               value=int(opt.get('form', '1')))
# Farbe ...
comboColor  = ComboBox(colorNames, width=8, value=int(opt.get('clr', '0')))
vBox2  = VBox([Label(tr('color')), comboColor], padding=16)

# Gruppe Rahmen zusammensetzen:
hBox5  = HBox([radio, vBox2],  padding=4,
               text=tr('frame'))

hBox5a = HBox([vBoxF, hBox5],padding=8)

#----------------------------------------------------
# vorhandene Taktnummern entfernen ...

check  = CheckBox(tr('delExtNum'),
                   value=int(opt.get('clear', '1')))

#----------------------------------------------------
#--- alles zusammensetzen:
vBox3 = VBox([hBox1, hBox4, hBox5a, check], padding=16, text=tr('setNum'))
#----------------------------------------------------

#----------------------------------------------------
# Subgruppe alle Taktnummern entfernen ...

check1 = CheckBox(tr('remAllNum'),
                   value=int(opt.get('clear1', '0')))
hBox6  = HBox([check1],text=tr('delNum'),padding=8)

vBox   = VBox([hBox0, vBox3, hBox6], padding=4)

dlg = Dialog(tr('barNum') + '     ' + 'Version: ' + version, vBox)

if dlg.run():
    activeScore().registerUndo("Taktnummerierung einfügen")
    step   = int(edit1.value())
    y      = comboY.value() - 15        ## WW - 15 war - 16 
    x      = comboX.value()
    form   = radio.value()
    ver    = radVer.value()
    clear  = check.value()
    clear1 = check1.value()
    behNo  = behindNo.value()
    color  = comboColor.value()
    colorF = comboColorF.value()
    size   = comboSize.value() + 5      ## WW war + 5 war +6
    #sansSerif = checkS.value()
    Sfett   = checkF.value()
    Skursiv = checkK.value()
    tfnt    = comFont.value()
    tfnt1   = FontList[comFont.value()]
       

    opt.update(dict(step=step, ver=ver, y=y, x=x, form=form, clear=clear, clear1=clear1, size=size, clrF=colorF, clr=color, behNo = behNo, Sfett=Sfett, Skursiv=Skursiv, tfnt=tfnt))
    options.set(opt)

    x = x - 3
    
    if clear1:
        activeScore().deleteTaggedGraphics(barNumTag)
        #activeScore().deleteTaggedGraphics('2086-50')
    else:
        if clear:
            activeScore().deleteTaggedGraphics(barNumTag)
            #if behNo == 1:
            #    activeScore().deleteTaggedGraphics('2086-50')

        if step >= 0:
            def showCond(n):
                if step == 0:                 # einzelne Taktnummer
                    return 0
                else:
                    return n % step == 0      # regelmäßige Taktnummern
            n = 1
            for s in activeScore().systems():
                barCount = s.getBarCount()
                if barCount['reset'] == 1:
                    n = 1
                n = n + barCount['nAdd']
                if n < 1:    # Fehler bei Eingabe
                    n = 1
                n = markBars(s.staff(0),
                             showCond,  # Bedingung für Anzeige
                             x,
                             -0.5 * y,  # vert. Lage
                             color,
                             size,
                             colorF,
                             form,      # Form
                             n          # Frequenz
                            )