ivan
/
chordsheet
1
0
Fork 0
Code Issues Pull Requests Releases 11 Wiki Activity
Browse Source

rewrite to use reportlab flowables for rendering

master
Ivan Holmes 5 years ago
parent
7d038f9973
commit
e38c6ebdab
11 changed files with 582 additions and 514 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 61
      chordsheet/components/chordprogression.py
  2. 56
      chordsheet/components/guitarchart.py
  3. 4
      chordsheet/components/header.py
  4. 6
      chordsheet/document.py
  5. 49
      chordsheet/parsers.py
  6. 48
      chordsheet/primitives.py
  7. 439
      chordsheet/render.py
  8. 34
      chordsheet/tableView.py
  9. 2
      examples/ah.xml
  10. 385
      gui.py
  11. 12
      test.py

61
chordsheet/components/chordprogression.py
View File

@ -1,61 +0,0 @@
# -*- coding: utf-8 -*-
from reportlab.pdfgen import canvas
from reportlab.lib.units import mm
from reportlab.lib.pagesizes import A4
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.graphics.shapes import *
from graphics.primitives import *
class ChordProgression:
def __init__(self, currentCanvas, blockList, **kwargs):
self.currentCanvas = currentCanvas
self.beatsHeight = kwargs.get('beatsHeight', 5*mm)
self.timeFontSize = kwargs.get('timeFontSize', 12)
self.chordNameFontSize = kwargs.get('chordNameFontSize', 18)
self.notesFontSize = kwargs.get('notesFontSize', 12)
self.unitWidth = kwargs.get('unitWidth', 10*mm)
self.unitHeight = kwargs.get('unitHeight', 20*mm)
self.timeSignature = kwargs.get('timeSignature', 4)
def draw(self):
global cur_pos, margin, pagesize
writeText(self.currentCanvas, "Chord progression", size=18, align="left")
v_origin = cur_pos + 2*mm + self.beatsHeight
h_origin = margin
h_loc = 0
v_loc = 0
maxWidth = int((((pagesize[0]-(2*margin))/self.unitWidth)//(self.timeSignature*2))*(self.timeSignature*2)) # use integer division to round maxWidth to nearest multiple of time signature
for u in range(maxWidth+1):
s = 0
x = u*self.unitWidth+margin
if u % self.timeSignature == 0:
e = -self.beatsHeight
else:
e = -self.beatsHeight/2
drawVertLine(self.currentCanvas, s, e, x, h_origin, v_origin)
if u == maxWidth: # Avoid writing beat number after the final line
break
writeText(str((u % self.timeSignature)+1),size=self.timeFontSize, hpos=x+self.unitWidth/2, vpos=v_origin-self.beatsHeight)
blockList = parseBlockList(self.blockList, maxWidth)
for b in blockList:
if h_loc == maxWidth:
v_loc += 1
h_loc = 0
currentCanvas.rect(h_origin+(h_loc*self.unitWidth), v_origin+(v_loc*self.unitHeight), b[0]*self.unitWidth, self.unitHeight)
if b[2]:
writeText(currentCanvas, b[2], size=self.notesFontSize, hpos=h_origin+((h_loc+b[0]/2)*self.unitWidth), vpos=v_origin+((v_loc+1)*self.unitHeight)-(1.3*self.notesFontSize))
v_offset = (v_loc*self.unitHeight+self.unitHeight/2)-self.chordNameFontSize/2
writeText(currentCanvas, parseName(b[1]), size=self.chordNameFontSize, hpos=h_origin+((h_loc+b[0]/2)*self.unitWidth), vpos=v_origin+v_offset)
h_loc += b[0]
cur_pos = v_origin+(v_loc+1)*self.unitHeight+self.beatsHeight

56
chordsheet/components/guitarchart.py
View File

@ -1,56 +0,0 @@
# -*- coding: utf-8 -*-
from reportlab.pdfgen import canvas
from reportlab.lib.units import mm
from reportlab.lib.pagesizes import A4
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.graphics.shapes import *
from graphics.primitives import *
string_hz_sp = 20*mm
string_hz_gap = 2*mm
string_height = 5*mm
def guitarChart(currentCanvas, string_hz_sp, string_hz_gap, string_height):
global cur_pos, margin, pagesize
writeText("Guitar chord voicings", size=18, align="left")
chartmargin = 15*mm
v_origin = cur_pos + 2*mm
h_origin = margin + chartmargin
nstrings = 6
fontsize = 12
guitarChordList = [[chordList[q].guitar[r] for q in range(len(chordList)) if hasattr(chordList[q], 'guitar')] for r in range(6)]
guitarChordList.append([chordList[q].name for q in range(len(chordList))])
for i in range(nstrings+1): # i is the string currently being drawn
writeText(['e','B','G','D','A','E','Name'][i], size=fontsize, hpos=(h_origin), vpos=v_origin+(i*string_height), align='right')
for j in range(len(ls.chords)): # j is which chord (0 is first chord, 1 is 2nd etc)
if j == 0:
charpos = string_hz_sp/2
s = string_hz_gap
e = charpos-((c.stringWidth(chordList[i][j])/2)+string_hz_gap)
y = v_origin+(string_height*i)+string_height/2
drawHorizLine(currentCanvas, s, e, y, h_origin, v_origin)
else:
charpos = string_hz_sp*(j+0.5)
s = charpos-string_hz_sp+(lastWidth/2+string_hz_gap)
e = charpos-((currentCanvas.stringWidth(chordList[i][j])/2)+string_hz_gap)
y = v_origin+(string_height*i)+string_height/2
drawHorizLine(currentCanvas, s, e, y, h_origin, v_origin)
if j == len(ls.chords)-1:
s = charpos+(currentCanvas.stringWidth(chordList[i][j])/2+string_hz_gap)
e = charpos+string_hz_sp/2
y = v_origin+(string_height*i)+string_height/2
drawHorizLine(currentCanvas, s, e, y, h_origin, v_origin)
writeText(chordList[i][j], size=fontsize, hpos=h_origin+charpos, vpos=v_origin+(i*string_height))
lastWidth = currentCanvas.stringWidth(chordList[i][j])
cur_pos += (string_height*(nstrings+2))

4
chordsheet/components/header.py
View File

@ -1,4 +0,0 @@
def header():
writeText(ls.title.cdata, size=24)
writeText("Composer: {c}".format(c = ls.composer.cdata), size=12)
writeText("Arranger: {a}".format(a = ls.arranger.cdata), size=12)

6
chordsheet/document.py
View File

@ -29,6 +29,10 @@ class Style:
self.unitHeight = 20*self.unit
self.beatsHeight = 5*self.unit
self.titleFontSize = 24
self.subtitleFontSize = 18
self.creditsFontSize = 12
self.tempoFontSize = 12
self.notesFontSize = 12
self.chordNameFontSize = 18
self.beatsFontSize = 12
@ -112,7 +116,7 @@ class Document:
self.timeSignature = (int(root.find('timesignature').text) if root.find('timesignature') is not None else defaultTimeSignature)
self.tempo = (root.find('tempo').text if root.find('tempo') is not None else None)
def newFromXML(filepath):
def newFromXML(self, filepath):
"""
Create a new Document object directly from an XML file.
"""

49
chordsheet/parsers.py
View File

@ -1,30 +1,33 @@
# -*- coding: utf-8 -*-
def parseFingering(fingering, instrument):
"""
Converts fingerings into the list format that Chord objects understand.
"""
if instrument == 'guitar':
numStrings = 6
if len(fingering) == numStrings: # if the fingering is entered in concise format e.g. xx4455
output = list(fingering)
else: # if entered in long format e.g. x,x,10,10,11,11
output = [x for x in fingering.split(',')]
if len(output) == numStrings:
return output
else:
raise Exception("Voicing <{}> is malformed.".format(fingering))
else:
return [fingering]
"""
Converts fingerings into the list format that Chord objects understand.
"""
if instrument == 'guitar':
numStrings = 6
if len(fingering) == numStrings: # if the fingering is entered in concise format e.g. xx4455
output = list(fingering)
else: # if entered in long format e.g. x,x,10,10,11,11
output = [x for x in fingering.split(',')]
if len(output) == numStrings:
return output
else:
raise Exception("Voicing <{}> is malformed.".format(fingering))
else:
return [fingering]
# dictionary holding text to be replaced in chord names
nameReplacements = { "b":"♭", "#":"♯" }
nameReplacements = {"b": "♭", "#": "♯"}
def parseName(chordName):
"""
Replaces symbols in chord names.
"""
parsedName = chordName
for i, j in nameReplacements.items():
parsedName = parsedName.replace(i, j)
return parsedName
"""
Replaces symbols in chord names.
"""
parsedName = chordName
for i, j in nameReplacements.items():
parsedName = parsedName.replace(i, j)
return parsedName

48
chordsheet/primitives.py
View File

@ -1,48 +0,0 @@
# -*- coding: utf-8 -*-
from reportlab.pdfgen import canvas
from reportlab.lib.units import mm
from reportlab.graphics.shapes import *
def writeText(currentCanvas, style, string, size, vpos, **kwargs):
"""
Wrapper function to conveniently write text and return how much vertical space it took up.
"""
margin = style.leftMargin*style.unit
align = kwargs.get('align', 'centre')
if align == 'centre' or align == 'center':
hpos = kwargs.get('hpos', style.pageSize[0]/2)
elif align == 'left':
hpos = kwargs.get('hpos', margin)
elif align == 'right':
hpos = kwargs.get('hpos', style.pageSize[0]-margin)
spacing = kwargs.get('spacing', style.lineSpacing)
currentCanvas.setFont(style.font, size)
if align == 'centre' or align == 'center':
currentCanvas.drawCentredString(hpos, vpos+(0.75*size*spacing),string)
elif align == 'left':
currentCanvas.drawString(hpos, vpos+(0.75*size*spacing),string)
elif align == 'right':
currentCanvas.drawString(hpos-currentCanvas.stringWidth(string), vpos+(0.75*size*spacing),string)
return size*style.lineSpacing
def drawHorizLine(currentCanvas, startpoint, endpoint, v_pos, h_origin, v_origin):
"""
Draw a horizontal line on the canvas taking origin point into account.
"""
x1 = h_origin+startpoint
x2 = h_origin+endpoint
currentCanvas.line(x1, v_pos, x2, v_pos)
def drawVertLine(currentCanvas, startpoint, endpoint, h_pos, h_origin, v_origin):
"""
Draw a vertical line on the canvas taking origin point into account.
"""
y1 = v_origin+startpoint
y2 = v_origin+endpoint
currentCanvas.line(h_pos, y1, h_pos, y2)

439
chordsheet/render.py
View File

@ -1,171 +1,290 @@
# -*- coding: utf-8 -*-
from math import trunc
from reportlab.pdfgen import canvas
from reportlab.lib.units import mm
from reportlab.graphics.shapes import *
from chordsheet.primitives import writeText, drawVertLine, drawHorizLine
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.platypus import BaseDocTemplate, Spacer, Paragraph, Flowable, Frame, PageTemplate
from chordsheet.document import Block
def writeText(canvas, style, string, size, vpos, width, **kwargs):
"""
Wrapper function to conveniently write text and return how much vertical space it took up.
"""
align = kwargs.get('align', 'centre')
if align == 'centre' or align == 'center':
hpos = kwargs.get('hpos', width/2)
elif align == 'left':
hpos = kwargs.get('hpos', 0)
elif align == 'right':
hpos = kwargs.get('hpos', width)
spacing = kwargs.get('spacing', style.lineSpacing)
canvas.setFont(style.font, size)
if align == 'centre' or align == 'center':
canvas.drawCentredString(hpos, vpos-(0.75*size*spacing), string)
elif align == 'left':
canvas.drawString(hpos, vpos-(0.75*size*spacing), string)
elif align == 'right':
canvas.drawString(hpos-canvas.stringWidth(string),
vpos-(0.75*size*spacing), string)
return size*style.lineSpacing
def splitBlocks(blockList, maxWidth):
h_loc = 0
splitBlockList = []
for i in range(len(blockList)):
c_orig = blockList[i].chord
n_orig = blockList[i].notes
if h_loc == maxWidth:
h_loc = 0
if h_loc+blockList[i].length > maxWidth:
lengthList = [maxWidth - h_loc]
while sum(lengthList) < blockList[i].length:
if blockList[i].length - sum(lengthList) >= maxWidth:
lengthList.append(maxWidth)
else:
lengthList.append(blockList[i].length - sum(lengthList))
for l in lengthList:
splitBlockList.append(Block(l, chord=c_orig, notes=n_orig)) # create a block with the given length
h_loc = lengthList[-1]
else:
splitBlockList.append(blockList[i])
h_loc += blockList[i].length
return splitBlockList
def guitarChart(currentCanvas, style, chordList, cur_pos):
title_height = writeText(currentCanvas, style, "Guitar chord voicings", 18, cur_pos, align="left")
cur_pos += title_height
string_hz_sp = style.stringHzSp
string_hz_gap = style.stringHzGap
string_height = style.stringHeight
margin = style.leftMargin*style.unit
pagesize = style.pageSize
chartmargin = 15*mm
v_origin = cur_pos + 2*mm
h_origin = margin + chartmargin
nstrings = 6
fontsize = 12
guitarChordList = [[chordList[q].voicings['guitar'][-(r+1)] for q in range(len(chordList)) if 'guitar' in chordList[q].voicings.keys()] for r in range(nstrings)]
guitarChordList.append([chordList[q].name for q in range(len(chordList)) if 'guitar' in chordList[q].voicings.keys()])
for i in range(nstrings+1): # i is the string currently being drawn
writeText(currentCanvas, style, ['e','B','G','D','A','E','Name'][i], fontsize, v_origin+(i*string_height), hpos=h_origin, align='right')
for j in range(len(guitarChordList[-1])): # j is which chord (0 is first chord, 1 is 2nd etc)
if j == 0:
charpos = string_hz_sp/2
s = string_hz_gap
e = charpos-((currentCanvas.stringWidth(guitarChordList[i][j])/2)+string_hz_gap)
y = v_origin+(string_height*i)+string_height/2
drawHorizLine(currentCanvas, s, e, y, h_origin, v_origin)
else:
charpos = string_hz_sp*(j+0.5)
s = charpos-string_hz_sp+(lastWidth/2+string_hz_gap)
e = charpos-((currentCanvas.stringWidth(guitarChordList[i][j])/2)+string_hz_gap)
y = v_origin+(string_height*i)+string_height/2
drawHorizLine(currentCanvas, s, e, y, h_origin, v_origin)
if j == len(guitarChordList[-1])-1:
s = charpos+(currentCanvas.stringWidth(guitarChordList[i][j])/2+string_hz_gap)
e = charpos+string_hz_sp/2
y = v_origin+(string_height*i)+string_height/2
drawHorizLine(currentCanvas, s, e, y, h_origin, v_origin)
writeText(currentCanvas, style, guitarChordList[i][j], fontsize, v_origin+(i*string_height), hpos=h_origin+charpos)
lastWidth = currentCanvas.stringWidth(guitarChordList[i][j])
return (string_height*(nstrings+1)) + title_height # calculate the height of the block
def chordProgression(currentCanvas, style, document, cur_pos):
margin = style.leftMargin*style.unit
unitWidth = style.unitWidth*style.unit
pagesize = style.pageSize
title_height = writeText(currentCanvas, style, "Chord progression", 18, cur_pos, align="left")
cur_pos += title_height
v_origin = cur_pos + 2*mm + style.beatsHeight
h_origin = margin
h_loc = 0
v_loc = 0
if (unitWidth * document.timeSignature * 2) >= ((pagesize[0]-(2*margin) + 1)): # adding 1 to allow for rounding errors
raise Exception("Beat width (unitWidth) is too high. It is {current} pt and can be a maximum of {max} pt".format(current = unitWidth, max = ((pagesize[0]-(2*margin)/(document.timeSignature * 2)))))
maxWidth = int((((pagesize[0]-(2*margin))/unitWidth)//(document.timeSignature*2))*(document.timeSignature*2)) # use integer division to round maxWidth to nearest two bars
for u in range(maxWidth+1):
s = 0
x = u*unitWidth+margin
if u % document.timeSignature == 0:
e = -style.beatsHeight
else:
e = -style.beatsHeight/2
drawVertLine(currentCanvas, s, e, x, h_origin, v_origin)
if u == maxWidth: # Avoid writing beat number after the final line
break
writeText(currentCanvas, style, str((u % document.timeSignature)+1), style.beatsFontSize, v_origin-style.beatsHeight, hpos=x+unitWidth/2)
parsedBlockList = splitBlocks(document.blockList, maxWidth)
for b in parsedBlockList:
if h_loc == maxWidth:
v_loc += 1
h_loc = 0
currentCanvas.rect(h_origin+(h_loc*unitWidth), v_origin+(v_loc*style.unitHeight), b.length*unitWidth, style.unitHeight)
if b.notes is not None:
writeText(currentCanvas, style, b.notes, style.notesFontSize, v_origin+((v_loc+1)*style.unitHeight)-(1.3*style.notesFontSize), hpos=h_origin+((h_loc+b.length/2)*unitWidth))
v_offset = ((v_loc*style.unitHeight)+style.unitHeight/2)-style.chordNameFontSize/2
if b.chord is not None:
writeText(currentCanvas, style, b.chord.name, style.chordNameFontSize, v_origin+v_offset, hpos=h_origin+((h_loc+b.length/2)*unitWidth))
h_loc += b.length
return v_origin + (v_loc+1)*style.unitHeight + style.beatsHeight + title_height # calculate the height of the generated chart
h_loc = 0
splitBlockList = []
for i in range(len(blockList)):
c_orig = blockList[i].chord
n_orig = blockList[i].notes
if h_loc == maxWidth:
h_loc = 0
if h_loc+blockList[i].length > maxWidth:
lengthList = [maxWidth - h_loc]
while sum(lengthList) < blockList[i].length:
if blockList[i].length - sum(lengthList) >= maxWidth:
lengthList.append(maxWidth)
else:
lengthList.append(blockList[i].length - sum(lengthList))
for l in lengthList:
# create a block with the given length
splitBlockList.append(Block(l, chord=c_orig, notes=n_orig))
h_loc = lengthList[-1]
else:
splitBlockList.append(blockList[i])
h_loc += blockList[i].length
return splitBlockList
class GuitarChart(Flowable):
"""
Flowable that draws a guitar chord voicing chart.
"""
def __init__(self, style, chordList):
self.style = style
self.guitarChordList = [
c for c in chordList if 'guitar' in c.voicings.keys()]
self.chartMargin = 15*mm
self.nStrings = 6
self.headingSize = 18
self.spaceAfter = self.style.separatorSize * mm
def wrap(self, availWidth, availHeight):
self.width = self.chartMargin + self.style.stringHzGap + self.style.stringHzSp * \
(len(self.guitarChordList)) # calculate the width of the flowable
self.height = self.style.stringHeight * \
(self.nStrings+1) + self.headingSize * \
self.style.lineSpacing + 2*mm # and its height
return (self.width, self.height)
def draw(self):
canvas = self.canv
title_height = writeText(canvas, self.style, "Guitar chord voicings",
self.headingSize, self.height, self.width, align="left")
chartmargin = self.chartMargin
v_origin = self.height - title_height - 2*mm
h_origin = chartmargin
self.nStrings = 6
fontsize = 12
stringList = [
[c.voicings['guitar'][-(r+1)] for c in self.guitarChordList] for r in range(self.nStrings)]
stringList.append([c.name for c in self.guitarChordList])
for i in range(self.nStrings+1): # i is the string line currently being drawn
writeText(canvas, self.style, ['e', 'B', 'G', 'D', 'A', 'E', 'Name'][i], fontsize, v_origin-(
i*self.style.stringHeight), self.width, hpos=h_origin, align='right')
# j is which chord (0 is first chord, 1 is 2nd etc)
for j in range(len(stringList[-1])):
currentWidth = canvas.stringWidth(stringList[i][j])
if j == 0:
x = self.style.stringHzGap + chartmargin
l = self.style.stringHzSp/2 - self.style.stringHzGap - \
((currentWidth/2)) - self.style.stringHzGap
y = v_origin-(self.style.stringHeight*i) - \
self.style.stringHeight/2
canvas.line(x, y, x+l, y)
else:
x = chartmargin + self.style.stringHzSp * \
(j-0.5)+(lastWidth/2+self.style.stringHzGap)
l = self.style.stringHzSp - currentWidth / \
2 - lastWidth/2 - self.style.stringHzGap*2
y = v_origin-(self.style.stringHeight*i) - \
self.style.stringHeight/2
canvas.line(x, y, x+l, y)
if j == len(stringList[-1])-1:
x = chartmargin + self.style.stringHzSp * \
(j+0.5) + currentWidth/2 + self.style.stringHzGap
l = self.style.stringHzSp/2 - currentWidth/2 - self.style.stringHzGap
y = v_origin-(self.style.stringHeight*i) - \
self.style.stringHeight/2
canvas.line(x, y, x+l, y)
writeText(canvas, self.style, stringList[i][j], fontsize, v_origin-(
i*self.style.stringHeight), self.width, hpos=chartmargin+self.style.stringHzSp*(j+0.5))
lastWidth = currentWidth
class ChordProgression(Flowable):
"""
Flowable that draws a chord progression made up of blocks.
"""
def __init__(self, style, blockList, timeSignature):
self.style = style
self.blockList = blockList
self.timeSignature = timeSignature
self.headingSize = 18
self.spaceAfter = self.style.separatorSize * mm
def wrap(self, availWidth, availHeight):
self.widthInBeats = 2 * self.timeSignature * \
trunc((availWidth/(self.style.unitWidth*self.style.unit)) /
(2*self.timeSignature)) # width of each line, in beats
self.width = self.widthInBeats * self.style.unitWidth * self.style.unit
self.height = self.headingSize * self.style.lineSpacing + 2 * mm + self.style.beatsHeight + \
self.style.unitHeight * \
sum([b.length for b in self.blockList]) / self.widthInBeats
return(self.width, self.height)
def draw(self):
canvas = self.canv
unitWidth = self.style.unitWidth*self.style.unit
title_height = writeText(canvas, self.style, "Chord progression",
self.headingSize, self.height, self.width, align="left")
v_origin = self.height - self.style.beatsHeight - title_height - 2*mm
h_origin = 0
h_loc = 0
v_loc = 0
maxWidth = self.widthInBeats
for u in range(maxWidth+1):
y = v_origin
x = u*unitWidth
if u % self.timeSignature == 0:
l = self.style.beatsHeight
else:
l = self.style.beatsHeight/2
canvas.line(x, y, x, y+l)
if u == maxWidth: # Avoid writing beat number after the final line
break
writeText(canvas, self.style, str((u % self.timeSignature)+1), self.style.beatsFontSize,
v_origin+self.style.beatsHeight, self.width, hpos=x+unitWidth/2)
parsedBlockList = splitBlocks(self.blockList, maxWidth)
for b in parsedBlockList:
if h_loc == maxWidth:
v_loc += 1
h_loc = 0
canvas.rect(h_loc*unitWidth, v_origin-((v_loc+1)*self.style.unitHeight),
b.length*unitWidth, self.style.unitHeight)
if b.notes is not None:
writeText(canvas, self.style, b.notes, self.style.notesFontSize, v_origin-((v_loc+1)*self.style.unitHeight)+(
1.3*self.style.notesFontSize), self.width, hpos=h_origin+((h_loc+b.length/2)*unitWidth))
v_offset = ((v_loc*self.style.unitHeight) +
self.style.unitHeight/2)-self.style.chordNameFontSize/2
if b.chord is not None:
writeText(canvas, self.style, b.chord.name, self.style.chordNameFontSize,
v_origin-v_offset, self.width, hpos=h_origin+((h_loc+b.length/2)*unitWidth))
h_loc += b.length
def guitarChartCheck(cL):
chordsPresent = False
for c in cL:
if 'guitar' in c.voicings.keys():
chordsPresent = True
break
return chordsPresent
chordsPresent = False
for c in cL:
if 'guitar' in c.voicings.keys():
chordsPresent = True
break
return chordsPresent
class TitleBlock(Flowable):
"""
Flowable that draws the title and other text at the top of the document.
"""
def __init__(self, style, document):
self.style = style
self.lS = style.lineSpacing
self.title = document.title
self.subtitle = document.subtitle
self.composer = document.composer
self.arranger = document.arranger
self.tempo = document.tempo
self.spaceAfter = self.style.separatorSize * mm
def wrap(self, availWidth, availHeight):
self.width = availWidth
self.height = sum([self.style.titleFontSize * self.lS if self.title else 0,
self.style.subtitleFontSize * self.lS if self.subtitle else 0,
self.style.creditsFontSize * self.lS if self.composer else 0,
self.style.titleFontSize * self.lS if self.arranger else 0,
self.style.tempoFontSize * self.lS if self.tempo else 0])
return(self.width, self.height)
def draw(self):
canvas = self.canv
curPos = self.height
if self.title:
curPos -= writeText(canvas, self.style,
self.title, 24, curPos, self.width)
if self.subtitle:
curPos -= writeText(canvas, self.style,
self.subtitle, 18, curPos, self.width)
if self.composer:
curPos -= writeText(canvas, self.style,
"Composer: {c}".format(c=self.composer), 12, curPos, self.width)
if self.arranger:
curPos -= writeText(canvas, self.style,
"Arranger: {a}".format(a=self.arranger), 12, curPos, self.width)
if self.tempo:
curPos -= writeText(canvas, self.style, "♩ = {t} bpm".format(
t=self.tempo), 12, curPos, self.width, align="left")
def savePDF(document, style, pathToPDF):
c = canvas.Canvas(pathToPDF, pagesize=style.pageSize, bottomup=0)
curPos = style.topMargin*style.unit
if document.title is not None:
curPos += writeText(c, style, document.title, 24, curPos)
if document.subtitle is not None:
curPos += writeText(c, style, document.subtitle, 18, curPos)
if document.composer is not None:
curPos += writeText(c, style, "Composer: {c}".format(c = document.composer), 12, curPos)
if document.arranger is not None:
curPos += writeText(c, style, "Arranger: {a}".format(a = document.arranger), 12, curPos)
if document.tempo is not None:
curPos += writeText(c, style, "♩ = {t} bpm".format(t = document.tempo), 12, curPos, align = "left")
curPos += style.separatorSize*style.unit
if guitarChartCheck(document.chordList):
curPos += guitarChart(c, style, document.chordList, curPos)
curPos += style.separatorSize*style.unit
if document.blockList:
curPos += chordProgression(c, style, document, curPos)
curPos += style.separatorSize*style.unit
c.save()
template = PageTemplate(id='AllPages', frames=[Frame(style.leftMargin*mm, style.topMargin*mm, style.pageSize[0] - style.leftMargin*mm*2, style.pageSize[1] - style.topMargin*mm*2,
leftPadding=0, bottomPadding=0, rightPadding=0, topPadding=0)])
rlDocList = []
rlDoc = BaseDocTemplate(
pathToPDF, pagesize=style.pageSize, pageTemplates=[template])
if document.title:
rlDocList.append(TitleBlock(style, document))
if guitarChartCheck(document.chordList):
rlDocList.append(GuitarChart(style, document.chordList))
if document.blockList:
rlDocList.append(ChordProgression(
style, document.blockList, document.timeSignature))
rlDoc.build(rlDocList)

34
chordsheet/tableView.py
View File

@ -1,15 +1,22 @@
import sys
from PyQt5 import QtWidgets, QtGui, QtCore
from PyQt5 import QtWidgets, QtGui
class MItemModel(QtGui.QStandardItemModel):
"""
Special item model to ensure whole row is moved.
"""
def dropMimeData(self, data, action, row, col, parent):
"""
Always move the entire row, and don't allow column "shifting"
"""
return super().dropMimeData(data, action, row, 0, parent)
class MProxyStyle(QtWidgets.QProxyStyle):
"""
Proxy style to change the appearance of the TableView.
"""
def drawPrimitive(self, element, option, painter, widget=None):
"""
@ -24,32 +31,36 @@ class MProxyStyle(QtWidgets.QProxyStyle):
option = option_new
super().drawPrimitive(element, option, painter, widget)
class MTableView(QtWidgets.QTableView):
"""
Subclass the built in TableView to customise it.
"""
def __init__(self, parent):
super().__init__(parent)
self.model = MItemModel()
self.model = MItemModel()
self.setModel(self.model)
self.verticalHeader().hide()
self.horizontalHeader().show()
self.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Interactive)
self.horizontalHeader().setStretchLastSection(True)
self.setShowGrid(False)
#self.setDragDropMode(self.InternalMove)
#self.setDragDropOverwriteMode(False)
# self.setDragDropMode(self.InternalMove)
# self.setDragDropOverwriteMode(False)
# Set our custom style - this draws the drop indicator across the whole row
self.setStyle(MProxyStyle())
class ChordTableView(MTableView):
"""
Subclass MTableView to add properties just for the chord table.
"""
def __init__(self, parent):
super().__init__(parent)
@ -61,7 +72,8 @@ class ChordTableView(MTableView):
"""
self.model.removeRows(0, self.model.rowCount())
for c in cList:
rowList = [QtGui.QStandardItem(c.name), QtGui.QStandardItem(",".join(c.voicings['guitar'] if 'guitar' in c.voicings.keys() else ""))]
rowList = [QtGui.QStandardItem(c.name), QtGui.QStandardItem(
",".join(c.voicings['guitar'] if 'guitar' in c.voicings.keys() else ""))]
for item in rowList:
item.setEditable(False)
item.setDropEnabled(False)
@ -73,6 +85,7 @@ class BlockTableView(MTableView):
"""
Subclass MTableView to add properties just for the block table.
"""
def __init__(self, parent):
super().__init__(parent)
@ -84,9 +97,10 @@ class BlockTableView(MTableView):
"""
self.model.removeRows(0, self.model.rowCount())
for b in bList:
rowList = [QtGui.QStandardItem((b.chord.name if b.chord else "")), QtGui.QStandardItem(str(b.length)), QtGui.QStandardItem(b.notes)]
rowList = [QtGui.QStandardItem((b.chord.name if b.chord else "")), QtGui.QStandardItem(
str(b.length)), QtGui.QStandardItem(b.notes)]
for item in rowList:
item.setEditable(False)
item.setDropEnabled(False)
self.model.appendRow(rowList)
self.model.appendRow(rowList)

2
examples/ah.xml
View File

@ -1,7 +1,9 @@
<chordsheet>
<title>"African Heritage"</title>
<subtitle>A corroboration</subtitle>
<composer>Ivan Holmes</composer>
<arranger>Ivan Holmes and Joe Buckley</arranger>
<tempo>120</tempo>
<timesignature>6</timesignature>
<chords>
<chord>

385
gui.py
View File

@ -6,15 +6,19 @@ Created on Wed May 29 00:02:24 2019
@author: ivan
"""
import sys, fitz, io, subprocess, os
import sys
import fitz
import io
import subprocess
import os
from copy import copy
from PyQt5.QtWidgets import QApplication, QAction, QLabel, QDialogButtonBox, QDialog, QFileDialog, QMessageBox, QPushButton, QLineEdit, QCheckBox, QSpinBox, QDoubleSpinBox, QTableWidgetItem, QTabWidget, QComboBox, QWidget, QScrollArea, QMainWindow, QShortcut
from PyQt5.QtCore import QFile, QObject, Qt, pyqtSlot, QSettings
from PyQt5.QtGui import QPixmap, QImage, QKeySequence
from PyQt5 import uic
from chordsheet.tableView import ChordTableView, BlockTableView , MItemModel, MProxyStyle
from chordsheet.tableView import ChordTableView, BlockTableView
from reportlab.lib.units import mm, cm, inch, pica
from reportlab.lib.pagesizes import A4, A5, LETTER, LEGAL
from reportlab.pdfbase import pdfmetrics
@ -32,24 +36,30 @@ if getattr(sys, 'frozen', False):
else:
scriptDir = os.path.abspath(os.path.dirname(os.path.abspath(__file__)))
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True) # enable automatic high DPI scaling on Windows
# enable automatic high DPI scaling on Windows
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
QApplication.setOrganizationName("Ivan Holmes")
QApplication.setOrganizationDomain("ivanholmes.co.uk")
QApplication.setApplicationName("Chordsheet")
settings = QSettings()
pdfmetrics.registerFont(TTFont('FreeSans', os.path.join(scriptDir, 'fonts', 'FreeSans.ttf')))
pdfmetrics.registerFont(
TTFont('FreeSans', os.path.join(scriptDir, 'fonts', 'FreeSans.ttf')))
if sys.platform == "darwin":
pdfmetrics.registerFont(TTFont('HelveticaNeue', 'HelveticaNeue.ttc', subfontIndex=0))
pdfmetrics.registerFont(
TTFont('HelveticaNeue', 'HelveticaNeue.ttc', subfontIndex=0))
# dictionaries for combo boxes
pageSizeDict = {'A4':A4, 'A5':A5, 'Letter':LETTER, 'Legal':LEGAL}
unitDict = {'mm':mm, 'cm':cm, 'inch':inch, 'point':1, 'pica':pica} # point is 1 because reportlab's native unit is points.
pageSizeDict = {'A4': A4, 'A5': A5, 'Letter': LETTER, 'Legal': LEGAL}
# point is 1 because reportlab's native unit is points.
unitDict = {'mm': mm, 'cm': cm, 'inch': inch, 'point': 1, 'pica': pica}
class DocumentWindow(QMainWindow):
"""
Class for the main window of the application.
"""
def __init__(self, doc, style, filename=None):
"""
Initialisation function for the main window of the application.
@ -59,14 +69,14 @@ class DocumentWindow(QMainWindow):
style -- the Style object for the window to use
"""
super().__init__()
self.doc = doc
self.style = style
self.lastDoc = copy(self.doc)
self.currentFilePath = filename
self.UIFileLoader(str(os.path.join(scriptDir, 'ui','mainwindow.ui')))
self.UIFileLoader(str(os.path.join(scriptDir, 'ui', 'mainwindow.ui')))
self.UIInitStyle()
self.updateChordDict()
@ -77,7 +87,7 @@ class DocumentWindow(QMainWindow):
if filename:
try:
self.openFile(filename)
except:
except Exception:
UnreadableMessageBox().exec()
def closeEvent(self, event):
@ -85,17 +95,17 @@ class DocumentWindow(QMainWindow):
Reimplement the built in closeEvent to allow asking the user to save.
"""
self.saveWarning()
def UIFileLoader(self, ui_file):
"""
Loads the .ui file for this window and connects the UI elements to their actions.
"""
ui_file = QFile(ui_file)
ui_file.open(QFile.ReadOnly)
self.window = uic.loadUi(ui_file)
ui_file.close()
# link all the UI elements
self.window.actionAbout.triggered.connect(self.menuFileAboutAction)
@ -103,7 +113,8 @@ class DocumentWindow(QMainWindow):
self.window.actionOpen.triggered.connect(self.menuFileOpenAction)
self.window.actionSave.triggered.connect(self.menuFileSaveAction)
self.window.actionSave_as.triggered.connect(self.menuFileSaveAsAction)
self.window.actionSave_PDF.triggered.connect(self.menuFileSavePDFAction)
self.window.actionSave_PDF.triggered.connect(
self.menuFileSavePDFAction)
self.window.actionPrint.triggered.connect(self.menuFilePrintAction)
self.window.actionClose.triggered.connect(self.menuFileCloseAction)
self.window.actionUndo.triggered.connect(self.menuEditUndoAction)
@ -125,25 +136,29 @@ class DocumentWindow(QMainWindow):
self.window.actionCopy.setShortcut(QKeySequence.Copy)
self.window.actionPaste.setShortcut(QKeySequence.Paste)
self.window.pageSizeComboBox.currentIndexChanged.connect(self.pageSizeAction)
self.window.documentUnitsComboBox.currentIndexChanged.connect(self.unitAction)
self.window.pageSizeComboBox.currentIndexChanged.connect(
self.pageSizeAction)
self.window.documentUnitsComboBox.currentIndexChanged.connect(
self.unitAction)
self.window.includedFontCheckBox.stateChanged.connect(
self.includedFontAction)
self.window.includedFontCheckBox.stateChanged.connect(self.includedFontAction)
self.window.generateButton.clicked.connect(self.generateAction)
self.window.guitarVoicingButton.clicked.connect(self.guitarVoicingAction)
self.window.guitarVoicingButton.clicked.connect(
self.guitarVoicingAction)
self.window.addChordButton.clicked.connect(self.addChordAction)
self.window.removeChordButton.clicked.connect(self.removeChordAction)
self.window.updateChordButton.clicked.connect(self.updateChordAction)
self.window.addBlockButton.clicked.connect(self.addBlockAction)
self.window.removeBlockButton.clicked.connect(self.removeBlockAction)
self.window.updateBlockButton.clicked.connect(self.updateBlockAction)
self.window.chordTableView.clicked.connect(self.chordClickedAction)
self.window.blockTableView.clicked.connect(self.blockClickedAction)
def UIInitDocument(self):
"""
Fills the window's fields with the values from its document.
@ -156,56 +171,63 @@ class DocumentWindow(QMainWindow):
self.window.arrangerLineEdit.setText(self.doc.arranger)
self.window.timeSignatureSpinBox.setValue(self.doc.timeSignature)
self.window.tempoLineEdit.setText(self.doc.tempo)
self.window.chordTableView.populate(self.doc.chordList)
self.window.blockTableView.populate(self.doc.blockList)
self.updateChordDict()
def UIInitStyle(self):
"""
Fills the window's fields with the values from its style.
"""
self.window.pageSizeComboBox.addItems(list(pageSizeDict.keys()))
self.window.pageSizeComboBox.setCurrentText(list(pageSizeDict.keys())[0])
self.window.pageSizeComboBox.setCurrentText(
list(pageSizeDict.keys())[0])
self.window.documentUnitsComboBox.addItems(list(unitDict.keys()))
self.window.documentUnitsComboBox.setCurrentText(list(unitDict.keys())[0])
self.window.documentUnitsComboBox.setCurrentText(
list(unitDict.keys())[0])
self.window.lineSpacingDoubleSpinBox.setValue(self.style.lineSpacing)
self.window.leftMarginLineEdit.setText(str(self.style.leftMargin))
self.window.topMarginLineEdit.setText(str(self.style.topMargin))
self.window.fontComboBox.setDisabled(True)
self.window.includedFontCheckBox.setChecked(True)
self.window.beatWidthLineEdit.setText(str(self.style.unitWidth))
def pageSizeAction(self, index):
self.pageSizeSelected = self.window.pageSizeComboBox.itemText(index)
def unitAction(self, index):
self.unitSelected = self.window.documentUnitsComboBox.itemText(index)
def includedFontAction(self):
if self.window.includedFontCheckBox.isChecked():
self.style.useIncludedFont = True
else:
self.style.useIncludedFont = False
def chordClickedAction(self, index):
# set the controls to the values from the selected chord
self.window.chordNameLineEdit.setText(self.window.chordTableView.model.item(index.row(), 0).text())
self.window.guitarVoicingLineEdit.setText(self.window.chordTableView.model.item(index.row(), 1).text())
self.window.chordNameLineEdit.setText(
self.window.chordTableView.model.item(index.row(), 0).text())
self.window.guitarVoicingLineEdit.setText(
self.window.chordTableView.model.item(index.row(), 1).text())
def blockClickedAction(self, index):
# set the controls to the values from the selected block
bChord = self.window.blockTableView.model.item(index.row(), 0).text()
self.window.blockChordComboBox.setCurrentText(bChord if bChord else "None")
self.window.blockLengthLineEdit.setText(self.window.blockTableView.model.item(index.row(), 1).text())
self.window.blockNotesLineEdit.setText(self.window.blockTableView.model.item(index.row(), 2).text())
self.window.blockChordComboBox.setCurrentText(
bChord if bChord else "None")
self.window.blockLengthLineEdit.setText(
self.window.blockTableView.model.item(index.row(), 1).text())
self.window.blockNotesLineEdit.setText(
self.window.blockTableView.model.item(index.row(), 2).text())
def getPath(self, value):
def getPath(self, value):
"""
Wrapper for Qt settings to return home directory if no setting exists.
"""
@ -218,14 +240,17 @@ class DocumentWindow(QMainWindow):
return settings.setValue(value, os.path.dirname(fullpath))
def menuFileNewAction(self):
self.doc = Document() # new document object
self.lastDoc = copy(self.doc) # copy this object as reference to check against on quitting
self.currentFilePath = None # reset file path (this document hasn't been saved yet)
self.doc = Document() #  new document object
# copy this object as reference to check against on quitting
self.lastDoc = copy(self.doc)
#  reset file path (this document hasn't been saved yet)
self.currentFilePath = None
self.UIInitDocument()
self.updatePreview()
def menuFileOpenAction(self):
filePath = QFileDialog.getOpenFileName(self.window.tabWidget, 'Open file', self.getPath("workingPath"), "Chordsheet ML files (*.xml *.cml)")[0]
filePath = QFileDialog.getOpenFileName(self.window.tabWidget, 'Open file', self.getPath(
"workingPath"), "Chordsheet ML files (*.xml *.cml)")[0]
if filePath:
self.openFile(filePath)
@ -239,18 +264,20 @@ class DocumentWindow(QMainWindow):
self.setPath("workingPath", self.currentFilePath)
self.UIInitDocument()
self.updatePreview()
def menuFileSaveAction(self):
self.updateDocument()
if not self.currentFilePath:
filePath = QFileDialog.getSaveFileName(self.window.tabWidget, 'Save file', self.getPath("workingPath"), "Chordsheet ML files (*.xml *.cml)")[0]
filePath = QFileDialog.getSaveFileName(self.window.tabWidget, 'Save file', self.getPath(
"workingPath"), "Chordsheet ML files (*.xml *.cml)")[0]
else:
filePath = self.currentFilePath
self.saveFile(filePath)
def menuFileSaveAsAction(self):
self.updateDocument()
filePath = QFileDialog.getSaveFileName(self.window.tabWidget, 'Save file', self.getPath("workingPath"), "Chordsheet ML files (*.xml *.cml)")[0]
filePath = QFileDialog.getSaveFileName(self.window.tabWidget, 'Save file', self.getPath(
"workingPath"), "Chordsheet ML files (*.xml *.cml)")[0]
if filePath:
self.saveFile(filePath)
@ -262,16 +289,17 @@ class DocumentWindow(QMainWindow):
self.doc.saveXML(self.currentFilePath)
self.lastDoc = copy(self.doc)
self.setPath("workingPath", self.currentFilePath)
self.updateTitleBar() # as we may have a new filename
self.updateTitleBar() # as we may have a new filename
def menuFileSavePDFAction(self):
self.updateDocument()
self.updatePreview()
filePath = QFileDialog.getSaveFileName(self.window.tabWidget, 'Save file', self.getPath("lastExportPath"), "PDF files (*.pdf)")[0]
filePath = QFileDialog.getSaveFileName(self.window.tabWidget, 'Save file', self.getPath(
"lastExportPath"), "PDF files (*.pdf)")[0]
if filePath:
savePDF(d, s, filePath)
self.setPath("lastExportPath", filePath)
def menuFilePrintAction(self):
if sys.platform == "darwin":
pass
@ -284,63 +312,64 @@ class DocumentWindow(QMainWindow):
self.saveWarning()
def menuFileAboutAction(self):
aDialog = AboutDialog()
AboutDialog()
def menuEditUndoAction(self):
try:
QApplication.focusWidget().undo() # see if the built in widget supports it
except:
pass # if not just fail silently
QApplication.focusWidget().undo() # see if the built in widget supports it
except Exception:
pass #  if not just fail silently
def menuEditRedoAction(self):
try:
QApplication.focusWidget().redo()
except:
except Exception:
pass
def menuEditCutAction(self):
try:
QApplication.focusWidget().cut()
except:
except Exception:
pass
def menuEditCopyAction(self):
try:
QApplication.focusWidget().copy()
except:
except Exception:
pass
def menuEditPasteAction(self):
try:
QApplication.focusWidget().paste()
except:
except Exception:
pass
def saveWarning(self):
"""
Function to check if the document has unsaved data in it and offer to save it.
"""
self.updateDocument() # update the document to catch all changes
self.updateDocument() # update the document to catch all changes
if (self.lastDoc == self.doc):
if self.lastDoc == self.doc:
self.close()
else:
wantToSave = UnsavedMessageBox().exec()
if wantToSave == QMessageBox.Save:
if not (self.currentFilePath):
filePath = QFileDialog.getSaveFileName(self.window.tabWidget, 'Save file', str(os.path.expanduser("~")), "Chordsheet ML files (*.xml *.cml)")
if not self.currentFilePath:
filePath = QFileDialog.getSaveFileName(self.window.tabWidget, 'Save file', str(
os.path.expanduser("~")), "Chordsheet ML files (*.xml *.cml)")
self.currentFilePath = filePath[0]
self.doc.saveXML(self.currentFilePath)
self.close()
elif wantToSave == QMessageBox.Discard:
self.close()
# if cancel or anything else do nothing at all
def guitarVoicingAction(self):
gdialog = GuitarDialog()
voicing = gdialog.getVoicing()
if voicing:
self.window.guitarVoicingLineEdit.setText(voicing)
@ -348,31 +377,32 @@ class DocumentWindow(QMainWindow):
def clearChordLineEdits(self):
self.window.chordNameLineEdit.clear()
self.window.guitarVoicingLineEdit.clear()
self.window.chordNameLineEdit.repaint() # necessary on Mojave with PyInstaller (or previous contents will be shown)
# necessary on Mojave with PyInstaller (or previous contents will be shown)
self.window.chordNameLineEdit.repaint()
self.window.guitarVoicingLineEdit.repaint()
def updateChordDict(self):
"""
Updates the dictionary used to generate the Chord menu (on the block tab)
"""
self.chordDict = {'None':None}
self.chordDict.update({c.name:c for c in self.doc.chordList})
self.chordDict = {'None': None}
self.chordDict.update({c.name: c for c in self.doc.chordList})
self.window.blockChordComboBox.clear()
self.window.blockChordComboBox.addItems(list(self.chordDict.keys()))
def removeChordAction(self):
if self.window.chordTableView.selectionModel().hasSelection(): # check for selection
if self.window.chordTableView.selectionModel().hasSelection(): #  check for selection
self.updateChords()
row = self.window.chordTableView.selectionModel().currentIndex().row()
self.doc.chordList.pop(row)
self.window.chordTableView.populate(self.doc.chordList)
self.clearChordLineEdits()
self.updateChordDict()
def addChordAction(self):
success = False # initialise
success = False # initialise
self.updateChords()
cName = parseName(self.window.chordNameLineEdit.text())
@ -380,23 +410,24 @@ class DocumentWindow(QMainWindow):
self.doc.chordList.append(Chord(cName))
if self.window.guitarVoicingLineEdit.text():
try:
self.doc.chordList[-1].voicings['guitar'] = parseFingering(self.window.guitarVoicingLineEdit.text(), 'guitar')
success = True # chord successfully parsed
except:
VoicingWarningMessageBox().exec() # Voicing is malformed, warn user
self.doc.chordList[-1].voicings['guitar'] = parseFingering(
self.window.guitarVoicingLineEdit.text(), 'guitar')
success = True #  chord successfully parsed
except Exception:
VoicingWarningMessageBox().exec() # Voicing is malformed, warn user
else:
success = True # chord successfully parsed
success = True #  chord successfully parsed
else:
NameWarningMessageBox().exec() # Chord has no name, warn user
NameWarningMessageBox().exec() # Chord has no name, warn user
if success == True: # if chord was parsed properly
if success == True: # if chord was parsed properly
self.window.chordTableView.populate(self.doc.chordList)
self.clearChordLineEdits()
self.updateChordDict()
def updateChordAction(self):
success = False # see comments above
if self.window.chordTableView.selectionModel().hasSelection(): # check for selection
success = False # see comments above
if self.window.chordTableView.selectionModel().hasSelection(): #  check for selection
self.updateChords()
row = self.window.chordTableView.selectionModel().currentIndex().row()
cName = parseName(self.window.chordNameLineEdit.text())
@ -404,71 +435,77 @@ class DocumentWindow(QMainWindow):
self.doc.chordList[row] = Chord(cName)
if self.window.guitarVoicingLineEdit.text():
try:
self.doc.chordList[row].voicings['guitar'] = parseFingering(self.window.guitarVoicingLineEdit.text(), 'guitar')
self.doc.chordList[row].voicings['guitar'] = parseFingering(
self.window.guitarVoicingLineEdit.text(), 'guitar')
success = True
except:
except Exception:
VoicingWarningMessageBox().exec()
else:
success = True
else:
NameWarningMessageBox().exec()
if success == True:
self.window.chordTableView.populate(self.doc.chordList)
self.clearChordLineEdits()
self.updateChordDict()
def clearBlockLineEdits(self):
self.window.blockLengthLineEdit.clear()
self.window.blockNotesLineEdit.clear()
self.window.blockLengthLineEdit.repaint() # necessary on Mojave with PyInstaller (or previous contents will be shown)
# necessary on Mojave with PyInstaller (or previous contents will be shown)
self.window.blockLengthLineEdit.repaint()
self.window.blockNotesLineEdit.repaint()
def removeBlockAction(self):
if self.window.blockTableView.selectionModel().hasSelection(): # check for selection
if self.window.blockTableView.selectionModel().hasSelection(): #  check for selection
self.updateBlocks()
row = self.window.blockTableView.selectionModel().currentIndex().row()
self.doc.blockList.pop(row)
self.window.blockTableView.populate(self.doc.blockList)
def addBlockAction(self):
self.updateBlocks()
try:
bLength = int(self.window.blockLengthLineEdit.text()) # can the value entered for block length be cast as an integer
except:
#  can the value entered for block length be cast as an integer
bLength = int(self.window.blockLengthLineEdit.text())
except Exception:
bLength = False
if bLength: # create the block
if bLength: # create the block
self.doc.blockList.append(Block(bLength,
chord = self.chordDict[self.window.blockChordComboBox.currentText()],
notes = (self.window.blockNotesLineEdit.text() if not "" else None)))
chord=self.chordDict[self.window.blockChordComboBox.currentText(
)],
notes=(self.window.blockNotesLineEdit.text() if not "" else None)))
self.window.blockTableView.populate(self.doc.blockList)
self.clearBlockLineEdits()
else:
LengthWarningMessageBox().exec() # show warning that length was not entered or in wrong format
# show warning that length was not entered or in wrong format
LengthWarningMessageBox().exec()
def updateBlockAction(self):
if self.window.blockTableView.selectionModel().hasSelection(): # check for selection
if self.window.blockTableView.selectionModel().hasSelection(): #  check for selection
self.updateBlocks()
try:
bLength = int(self.window.blockLengthLineEdit.text())
except:
except Exception:
bLength = False
row = self.window.blockTableView.selectionModel().currentIndex().row()
if bLength:
self.doc.blockList[row] = (Block(bLength,
chord = self.chordDict[self.window.blockChordComboBox.currentText()],
notes = (self.window.blockNotesLineEdit.text() if not "" else None)))
chord=self.chordDict[self.window.blockChordComboBox.currentText(
)],
notes=(self.window.blockNotesLineEdit.text() if not "" else None)))
self.window.blockTableView.populate(self.doc.blockList)
self.clearBlockLineEdits()
else:
LengthWarningMessageBox().exec()
def generateAction(self):
self.updateDocument()
self.updatePreview()
@ -482,23 +519,28 @@ class DocumentWindow(QMainWindow):
savePDF(self.doc, self.style, self.currentPreview)
pdfView = fitz.Document(stream=self.currentPreview, filetype='pdf')
pix = pdfView[0].getPixmap(matrix = fitz.Matrix(4, 4), alpha = False) # render at 4x resolution and scale
# render at 4x resolution and scale
pix = pdfView[0].getPixmap(matrix=fitz.Matrix(4, 4), alpha=False)
fmt = QImage.Format_RGB888
qtimg = QImage(pix.samples, pix.width, pix.height, pix.stride, fmt)
self.window.imageLabel.setPixmap(QPixmap.fromImage(qtimg).scaled(self.window.scrollArea.width()-30, self.window.scrollArea.height()-30, Qt.KeepAspectRatio, transformMode=Qt.SmoothTransformation))
self.window.imageLabel.setPixmap(QPixmap.fromImage(qtimg).scaled(self.window.scrollArea.width(
)-30, self.window.scrollArea.height()-30, Qt.KeepAspectRatio, transformMode=Qt.SmoothTransformation))
# -30 because the scrollarea has a margin of 12 each side (extra for safety)
self.window.imageLabel.repaint() # necessary on Mojave with PyInstaller (or previous contents will be shown)
except:
warning = QMessageBox.warning(self, "Preview failed", "Could not update the preview.", buttons=QMessageBox.Ok, defaultButton=QMessageBox.Ok)
# necessary on Mojave with PyInstaller (or previous contents will be shown)
self.window.imageLabel.repaint()
except Exception:
QMessageBox.warning(self, "Preview failed", "Could not update the preview.",
buttons=QMessageBox.Ok, defaultButton=QMessageBox.Ok)
def updateTitleBar(self):
"""
Update the application's title bar to reflect the current document.
"""
if self.currentFilePath:
self.setWindowTitle(_version.appName + " – " + os.path.basename(self.currentFilePath))
self.setWindowTitle(_version.appName + " – " +
os.path.basename(self.currentFilePath))
else:
self.setWindowTitle(_version.appName)
@ -508,69 +550,91 @@ class DocumentWindow(QMainWindow):
"""
chordTableList = []
for i in range(self.window.chordTableView.model.rowCount()):
chordTableList.append(Chord(parseName(self.window.chordTableView.model.item(i, 0).text()))),
chordTableList.append(
Chord(parseName(self.window.chordTableView.model.item(i, 0).text()))),
if self.window.chordTableView.model.item(i, 1).text():
chordTableList[-1].voicings['guitar'] = parseFingering(self.window.chordTableView.model.item(i, 1).text(), 'guitar')
chordTableList[-1].voicings['guitar'] = parseFingering(
self.window.chordTableView.model.item(i, 1).text(), 'guitar')
self.doc.chordList = chordTableList
def updateBlocks(self):
"""
Update the block list by reading the table.
"""
blockTableList = []
for i in range(self.window.blockTableView.model.rowCount()):
blockLength = int(self.window.blockTableView.model.item(i, 1).text())
blockChord = self.chordDict[(self.window.blockTableView.model.item(i, 0).text() if self.window.blockTableView.model.item(i, 0).text() else "None")]
blockNotes = self.window.blockTableView.model.item(i, 2).text() if self.window.blockTableView.model.item(i, 2).text() else None
blockTableList.append(Block(blockLength, chord=blockChord, notes=blockNotes))
blockLength = int(
self.window.blockTableView.model.item(i, 1).text())
blockChord = self.chordDict[(self.window.blockTableView.model.item(
i, 0).text() if self.window.blockTableView.model.item(i, 0).text() else "None")]
blockNotes = self.window.blockTableView.model.item(i, 2).text(
) if self.window.blockTableView.model.item(i, 2).text() else None
blockTableList.append(
Block(blockLength, chord=blockChord, notes=blockNotes))
self.doc.blockList = blockTableList
def updateDocument(self):
"""
Update the Document object by reading values from the UI.
"""
self.doc.title = self.window.titleLineEdit.text() # Title can be empty string but not None
self.doc.subtitle = (self.window.subtitleLineEdit.text() if self.window.subtitleLineEdit.text() else None)
self.doc.composer = (self.window.composerLineEdit.text() if self.window.composerLineEdit.text() else None)
self.doc.arranger = (self.window.arrangerLineEdit.text() if self.window.arrangerLineEdit.text() else None)
self.doc.tempo = (self.window.tempoLineEdit.text() if self.window.tempoLineEdit.text() else None)
self.doc.timeSignature = int(self.window.timeSignatureSpinBox.value()) if self.window.timeSignatureSpinBox.value() else self.doc.timeSignature
self.doc.title = self.window.titleLineEdit.text(
) # Title can be empty string but not None
self.doc.subtitle = (self.window.subtitleLineEdit.text(
) if self.window.subtitleLineEdit.text() else None)
self.doc.composer = (self.window.composerLineEdit.text(
) if self.window.composerLineEdit.text() else None)
self.doc.arranger = (self.window.arrangerLineEdit.text(
) if self.window.arrangerLineEdit.text() else None)
self.doc.tempo = (self.window.tempoLineEdit.text()
if self.window.tempoLineEdit.text() else None)
self.doc.timeSignature = int(self.window.timeSignatureSpinBox.value(
)) if self.window.timeSignatureSpinBox.value() else self.doc.timeSignature
self.style.pageSize = pageSizeDict[self.pageSizeSelected]
self.style.unit = unitDict[self.unitSelected]
self.style.leftMargin = float(self.window.leftMarginLineEdit.text()) if self.window.leftMarginLineEdit.text() else self.style.leftMargin
self.style.topMargin = float(self.window.topMarginLineEdit.text()) if self.window.topMarginLineEdit.text() else self.style.topMargin
self.style.lineSpacing = float(self.window.lineSpacingDoubleSpinBox.value()) if self.window.lineSpacingDoubleSpinBox.value() else self.style.lineSpacing
self.style.leftMargin = float(self.window.leftMarginLineEdit.text(
)) if self.window.leftMarginLineEdit.text() else self.style.leftMargin
self.style.topMargin = float(self.window.topMarginLineEdit.text(
)) if self.window.topMarginLineEdit.text() else self.style.topMargin
self.style.lineSpacing = float(self.window.lineSpacingDoubleSpinBox.value(
)) if self.window.lineSpacingDoubleSpinBox.value() else self.style.lineSpacing
# make sure the unit width isn't too wide to draw!
if self.window.beatWidthLineEdit.text():
if (self.style.pageSize[0] - 2 * self.style.leftMargin * mm) >= (float(self.window.beatWidthLineEdit.text()) * 2 * self.doc.timeSignature * mm):
self.style.unitWidth = float(self.window.beatWidthLineEdit.text())
self.style.unitWidth = float(
self.window.beatWidthLineEdit.text())
else:
maxBeatWidth = (self.style.pageSize[0] - 2 * self.style.leftMargin * mm) / (2 * self.doc.timeSignature * mm)
warning = QMessageBox.warning(self, "Out of range", "Beat width is out of range. It can be a maximum of {}.".format(maxBeatWidth), buttons=QMessageBox.Ok, defaultButton=QMessageBox.Ok)
maxBeatWidth = (
self.style.pageSize[0] - 2 * self.style.leftMargin * mm) / (2 * self.doc.timeSignature * mm)
QMessageBox.warning(self, "Out of range", "Beat width is out of range. It can be a maximum of {}.".format(
maxBeatWidth), buttons=QMessageBox.Ok, defaultButton=QMessageBox.Ok)
self.updateChords()
self.updateBlocks()
self.style.font = ('FreeSans' if self.style.useIncludedFont else 'HelveticaNeue')
self.style.font = (
'FreeSans' if self.style.useIncludedFont else 'HelveticaNeue')
# something for the font box here
class GuitarDialog(QDialog):
"""
Dialogue to allow the user to enter a guitar chord voicing. Not particularly advanced at present!
May be extended in future.
"""
def __init__(self):
super().__init__()
self.UIFileLoader(str(os.path.join(scriptDir, 'ui','guitardialog.ui')))
self.UIFileLoader(
str(os.path.join(scriptDir, 'ui', 'guitardialog.ui')))
def UIFileLoader(self, ui_file):
ui_file = QFile(ui_file)
ui_file.open(QFile.ReadOnly)
self.dialog = uic.loadUi(ui_file)
ui_file.close()
@ -590,32 +654,37 @@ class GuitarDialog(QDialog):
else:
return None
class AboutDialog(QDialog):
"""
Dialogue showing information about the program.
"""
def __init__(self):
super().__init__()
self.UIFileLoader(str(os.path.join(scriptDir, 'ui','aboutdialog.ui')))
icon = QImage(str(os.path.join(scriptDir, 'ui','icon.png')))
self.dialog.iconLabel.setPixmap(QPixmap.fromImage(icon).scaled(self.dialog.iconLabel.width(), self.dialog.iconLabel.height(), Qt.KeepAspectRatio, transformMode=Qt.SmoothTransformation))
self.UIFileLoader(str(os.path.join(scriptDir, 'ui', 'aboutdialog.ui')))
icon = QImage(str(os.path.join(scriptDir, 'ui', 'icon.png')))
self.dialog.iconLabel.setPixmap(QPixmap.fromImage(icon).scaled(self.dialog.iconLabel.width(
), self.dialog.iconLabel.height(), Qt.KeepAspectRatio, transformMode=Qt.SmoothTransformation))
self.dialog.versionLabel.setText("Version " + _version.version)
self.dialog.exec()
def UIFileLoader(self, ui_file):
ui_file = QFile(ui_file)
ui_file.open(QFile.ReadOnly)
self.dialog = uic.loadUi(ui_file)
ui_file.close()
class UnsavedMessageBox(QMessageBox):
"""
Message box to alert the user of unsaved changes and allow them to choose how to act.
"""
def __init__(self):
super().__init__()
@ -623,13 +692,16 @@ class UnsavedMessageBox(QMessageBox):
self.setWindowTitle("Unsaved changes")
self.setText("The document has been modified.")
self.setInformativeText("Do you want to save your changes?")
self.setStandardButtons(QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
self.setStandardButtons(
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
self.setDefaultButton(QMessageBox.Save)
class UnreadableMessageBox(QMessageBox):
"""
Message box to warn the user that the chosen file cannot be opened.
"""
def __init__(self):
super().__init__()
@ -640,10 +712,12 @@ class UnreadableMessageBox(QMessageBox):
self.setStandardButtons(QMessageBox.Ok)
self.setDefaultButton(QMessageBox.Ok)
class NameWarningMessageBox(QMessageBox):
"""
Message box to warn the user that a chord must have a name
"""
def __init__(self):
super().__init__()
@ -654,42 +728,51 @@ class NameWarningMessageBox(QMessageBox):
self.setStandardButtons(QMessageBox.Ok)
self.setDefaultButton(QMessageBox.Ok)
class VoicingWarningMessageBox(QMessageBox):
"""
Message box to warn the user that the voicing entered could not be parsed
"""
def __init__(self):
super().__init__()
self.setIcon(QMessageBox.Warning)
self.setWindowTitle("Malformed voicing")
self.setText("The voicing you entered was not understood and has not been applied.")
self.setInformativeText("Please try re-entering it in the correct format.")
self.setText(
"The voicing you entered was not understood and has not been applied.")
self.setInformativeText(
"Please try re-entering it in the correct format.")
self.setStandardButtons(QMessageBox.Ok)
self.setDefaultButton(QMessageBox.Ok)
class LengthWarningMessageBox(QMessageBox):
"""
Message box to warn the user that a block must have a length
"""
def __init__(self):
super().__init__()
self.setIcon(QMessageBox.Warning)
self.setWindowTitle("Block without valid length")
self.setText("Blocks must have a whole number length.")
self.setInformativeText("Please enter a valid length for your block and try again.")
self.setInformativeText(
"Please enter a valid length for your block and try again.")
self.setStandardButtons(QMessageBox.Ok)
self.setDefaultButton(QMessageBox.Ok)
if __name__ == '__main__':
app = QApplication(sys.argv)
d = Document()
s = Style()
w = DocumentWindow(d, s, filename=(sys.argv[1] if len(sys.argv) > 1 else None)) # pass first argument as filename
# pass first argument as filename
w = DocumentWindow(d, s, filename=(
sys.argv[1] if len(sys.argv) > 1 else None))
w.show()
sys.exit(app.exec_())

12
test.py
View File

@ -0,0 +1,12 @@
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from chordsheet.document import Document, Style
from chordsheet.render import savePDF
pdfmetrics.registerFont(TTFont('FreeSans', os.path.join('fonts', 'FreeSans.ttf')))
doc = Document.newFromXML('examples/example.xml')
style = Style()
savePDF(doc, style, 'test.pdf')
Write Preview
Loading…
Cancel
Save