You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

515 lines
25 KiB

5 years ago
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright 2020, Nils Hilbricht, Germany ( https://www.hilbricht.net )
5 years ago
5 years ago
This file is part of the Laborejo Software Suite ( https://www.laborejo.org ),
5 years ago
5 years ago
Laborejo2 is free software: you can redistribute it and/or modify
5 years ago
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
import logging; logger = logging.getLogger(__name__); logger.info("import")
5 years ago
#Standard Library
5 years ago
from math import log
#Third party
5 years ago
from PyQt5 import QtCore, QtGui, QtWidgets
translate = QtCore.QCoreApplication.translate
5 years ago
#Template
from template.qtgui.helper import stringToColor
from template.qtgui.helper import stretchLine, stretchRect, callContextMenu, removeInstancesFromScene
#Our own files
import engine.api as api
from . import graphs
5 years ago
from .items import staticItem2Item, GuiTieCurveGraphicsItem
5 years ago
from .constantsAndConfigs import constantsAndConfigs
from .submenus import BlockPropertiesEdit
cosmeticPen = QtGui.QPen()
cosmeticPen.setCosmetic(True)
class GuiBlockHandle(QtWidgets.QGraphicsRectItem):
"""A simplified version of a Block. Since we don't use blocks in the GUI, only in the backend
we still need them sometimes as macro strutures, where we don't care about the content.
This is the transparent Block handle that appears when the user uses the mouse to drag and drop
a block.
5 years ago
It is visible all the time though and can be clicked on. In opposite to the background color,
which is just a color and stays in place.
"""
def __init__(self, parent, staticExportItem, x, y, w, h):
super().__init__(x, y, w, h)
#self.setFlag(QtWidgets.QGraphicsItem.ItemHasNoContents, True) #only child items. Without this we get notImplementedError: QGraphicsItem.paint() is abstract and must be overridden
#self.setFlag(QtWidgets.QGraphicsItem.ItemContainsChildrenInShape, True)
5 years ago
self.parent = parent #GuiTrack instance
self.color = None #QColor inserted by the creating function in GuiTrack. Used during dragging, then reset to transparent.
5 years ago
self.trans = QtGui.QColor("transparent")
self.setPen(self.trans)
self.setBrush(self.trans)
#self.setOpacity(0.4) #slightly fuller than background
5 years ago
self.setFlag(QtWidgets.QGraphicsItem.ItemIgnoresParentOpacity)
self.setParentItem(parent)
self.setZValue(10) #This is the z value within GuiTrack
self.staticExportItem = staticExportItem
self.posBeforeMove = None
self.cursorPosOnMoveStart = None
#Display Block ID
"""
self.idText = QtWidgets.QGraphicsSimpleTextItem(str(self.staticExportItem["id"]))
self.idText.setParentItem(self)
self.idText.setPos(0, constantsAndConfigs.stafflineGap)
#self.idText.setScale(4)
self.idText.setFlags(QtWidgets.QGraphicsItem.ItemIgnoresParentOpacity)
"""
if self.staticExportItem["completeDuration"] >= 3 * api.D1: #cosmetics
self.startLabel = QtWidgets.QGraphicsSimpleTextItem(self.staticExportItem["name"])
self.endLabel = QtWidgets.QGraphicsSimpleTextItem(self.staticExportItem["name"] + translate("musicstructures", " end "))
5 years ago
else:
self.startLabel = QtWidgets.QGraphicsSimpleTextItem("")
self.endLabel = QtWidgets.QGraphicsSimpleTextItem("")
self.startLabel.setParentItem(self)
self.startLabel.setPos(0, constantsAndConfigs.stafflineGap)
self.startLabel.setFlags(QtWidgets.QGraphicsItem.ItemIgnoresParentOpacity)
self.endLabel.setParentItem(self)
self.endLabel.setPos(self.rect().width() - self.endLabel.boundingRect().width(), constantsAndConfigs.stafflineGap)
self.endLabel.setFlags(QtWidgets.QGraphicsItem.ItemIgnoresParentOpacity)
5 years ago
def stretchXCoordinates(self, factor):
"""Reposition the items on the X axis.
Call goes through all parents/children, starting from ScoreView._stretchXCoordinates.
Docstring there."""
stretchRect(self, factor)
self.endLabel.setPos(self.rect().width() - self.endLabel.boundingRect().width(), constantsAndConfigs.stafflineGap)
def blockMode(self):
self.startLabel.show()
self.endLabel.show()
def itemMode(self):
self.startLabel.hide()
self.endLabel.hide()
def mousePressEventCustom(self, event):
"""Not a qt-override. This is called directly by GuiScore
if you click on a block with the right modifier keys (none)"""
5 years ago
self.posBeforeMove = self.pos()
self.cursorPosOnMoveStart = QtGui.QCursor.pos()
self.setBrush(self.color)
self.endLabel.hide()
5 years ago
super().mousePressEvent(event)
def mouseReleaseEventCustom(self, event):
"""Not a qt-override. This is called directly by GuiScore
if you click-release on a block"""
5 years ago
self.setBrush(self.trans)
self.setPos(self.posBeforeMove) #In case the block was moved to a position where no track is (below the tracks) we just reset the graphics.
self.posBeforeMove = None
self.cursorPosOnMoveStart = None
self.endLabel.show()
5 years ago
super().mouseReleaseEvent(event)
def contextMenuEvent(self, event):
if self.startLabel.isVisible():
listOfLabelsAndFunctions = [
(translate("musicstructures", "edit properties"), lambda: BlockPropertiesEdit(self.scene().parentView.mainWindow, staticExportItem = self.staticExportItem)),
5 years ago
("separator", None),
#("split here", lambda: self.splitHere(event)), #Impossible because we can't see notes.
(translate("musicstructures", "duplicate"), lambda: api.duplicateBlock(self.staticExportItem["id"])),
(translate("musicstructures", "create content link"), lambda: api.duplicateContentLinkBlock(self.staticExportItem["id"])),
(translate("musicstructures", "unlink"), lambda: api.unlinkBlock(self.staticExportItem["id"])),
5 years ago
("separator", None),
(translate("musicstructures", "join with next block"), lambda: api.joinBlockWithNext(self.staticExportItem["id"])),
(translate("musicstructures", "delete block"), lambda: api.deleteBlock(self.staticExportItem["id"])),
5 years ago
("separator", None),
(translate("musicstructures", "append block at the end"), lambda: api.appendBlock(self.parent.staticExportItem["id"])),
5 years ago
]
callContextMenu(listOfLabelsAndFunctions)
else:
super().contextMenuEvent(event)
class GuiTrack(QtWidgets.QGraphicsItem):
"""In opposite to tracks and block(backgrounds and handles) tracks never get recreated.
Init is called once on creation, not virtually on every update.
However, the track children, its parts, get deleted and recreated very often.
Order of creation:
init
stafflines
second init
update edit mode
-> then api takes over and instructs the following methods through callbacks
Typical order of method calls for updates:
barlines
beams
stafflines
items
redraw
background color
update edit mode (not on every item update, but at least on load)
"""
def __init__(self, parentScore, staticExportItem):
super().__init__()
self.setFlag(QtWidgets.QGraphicsItem.ItemHasNoContents, True) #only child items. Without this we get notImplementedError: QGraphicsItem.paint() is abstract and must be overridden
self.setFlag(QtWidgets.QGraphicsItem.ItemContainsChildrenInShape, True)
5 years ago
self.parentScore = parentScore
self.staticExportItem = staticExportItem #This is not the notes but the track meta data. The notes are called staticRepresentationList
self.items = [] #this is used for stretching and processing of the current items. scene clear is done diffently. See self.createGraphicItemsFromData
self.barLines = []
self.beams = []
self.staffLines = []
self.staticItems = [] #not deleted automatically by callbacks.
self.ItemIgnoresTransformations = [] #not literally colors. QRectItems with a color. created in self.paintBlockBackgroundColors()
self.transparentBlockHandles = [] #list of GuiBlockHandle in order. Only appear when the mouse is used to drag and drop.
self.backgroundBlockColors = [] #QGraphicsRectItems. Always visible.
self.lengthInPixel = 0 # a cached value
self.createStaffLines() #no stafflines at all are too confusing.
self.ccPaths = {} # ccNumber0-127:PathItem. Empty for a new track. We only create ccPaths with the first ccBlock. Creation and handling is done in GuiScore, starting with syncCCsToBackend.
self.nameGraphic = self.NameGraphic(self.staticExportItem["name"], parent = self)
self.staticItems.append(self.nameGraphic)
#Add one central "Create new CC Path" button which is for all non-existing CC Paths of this track and reacte to the current constantsAndConfig.ccValue
#This button is not in the CCPath object because those only get created for existing backend-CCs.
self.universalCreateFirstCCBlock = QtWidgets.QGraphicsSimpleTextItem(translate("musicstructures", "Create CC Path"))
5 years ago
self.universalCreateFirstCCBlock.setFlag(QtWidgets.QGraphicsItem.ItemIgnoresParentOpacity) #toggle between edit modes not only hides stuff but the track itself gets 10% opacity. We want to avoid it for this item.
self.universalCreateFirstCCBlock.mousePressEvent = lambda mouseEvent: api.newGraphTrackCC(trId = self.staticExportItem["id"], cc = constantsAndConfigs.ccViewValue) #trigger callback to self.syncCCsToBackend
self.universalCreateFirstCCBlock.setParentItem(self)
self.universalCreateFirstCCBlock.setPos(0,0) #for now. Afterwards it gets updated by updateBlocks .
self.universalCreateFirstCCBlock.setZValue(10)
#self.secondStageInitNowThatWeHaveAScene gets called by the ScoreScene.redraw(), where new tracks get created. After it was inserted into the scene.
5 years ago
class NameGraphic(QtWidgets.QGraphicsSimpleTextItem):
def __init__(self, text, parent):
super().__init__(text)
self.setFlags(QtWidgets.QGraphicsItem.ItemIgnoresParentOpacity)
self.parent = parent
self.setParentItem(parent)
def _editName(self):
result = QtWidgets.QInputDialog.getText(self.scene().parentView, translate("musicstructures", "Track Name"), #dialog title
translate("musicstructures", "Set Track Name for {}").format(self.parent.staticExportItem["id"]), #label
5 years ago
QtWidgets.QLineEdit.Normal,
self.parent.staticExportItem["name"]
)
if result[1]:
api.setTrackName(self.parent.staticExportItem["id"], nameString = result[0], initialInstrumentName = self.parent.staticExportItem["initialInstrumentName"], initialShortInstrumentName = self.parent.staticExportItem["initialShortInstrumentName"]) #keep the old lilypond names
def contextMenuEvent(self, event):
listOfLabelsAndFunctions = [ (translate("musicstructures", "edit name"), self._editName), ]
5 years ago
callContextMenu(listOfLabelsAndFunctions)
event.accept()
def secondStageInitNowThatWeHaveAScene(self):
"""ScoreScene.redraw() calls this after the track was inserted into the scene and therefore
has a position, opacity, parent item etc. (All of that is not read in normal __init__)"""
pass
def boundingRect(self):
"""Without bounding rect not mousePressEvents for children"""
if self.staticExportItem["double"]: #double track, twice as high
h = 10 * constantsAndConfigs.stafflineGap
else:
h = 4 * constantsAndConfigs.stafflineGap
w = self.lengthInPixel
return QtCore.QRectF(0,0,w,h) #x,y,w,h - relative to self, so pos is always 0,0
5 years ago
def toggleNoteheadsRectangles(self):
for item in self.items:
item.updateVisibility()
for beam in self.beams:
beam.rectangle.setVisible(constantsAndConfigs.noteHeadMode)
def redraw(self, staticRepresentationList):
self.createGraphicItemsFromData(staticRepresentationList)
self.nameGraphic.setPos(30 + self.lengthInPixel, -1*constantsAndConfigs.stafflineGap) #self.lengthInPixel is now up to date
def paintBlockBackgroundColors(self, staticBlocksRepresentation):
"""This gets not called by self.createGraphicItemsFromData but only by
a score callback for blocksChanged"""
for bg in self.backgroundBlockColors:
self.parentScore.removeWhenIdle(bg)
for th in self.transparentBlockHandles:
self.parentScore.removeWhenIdle(th)
self.backgroundBlockColors = []
self.transparentBlockHandles = []
for block in staticBlocksRepresentation:
if self.staticExportItem["double"]: #double track, twice as high
h = 10 * constantsAndConfigs.stafflineGap
else:
h = 4 * constantsAndConfigs.stafflineGap
bgItem = QtWidgets.QGraphicsRectItem(0, 0, block["completeDuration"] / constantsAndConfigs.ticksToPixelRatio, h) #x, y, w, h
bgItem.setFlag(QtWidgets.QGraphicsItem.ItemIgnoresParentOpacity)
bgItem.setPen(QtGui.QColor("transparent"))
color = stringToColor(block["name"])
5 years ago
bgItem.setBrush(color)
bgItem.setParentItem(self)
self.backgroundBlockColors.append(bgItem)
bgItem.setPos(block["tickindex"] / constantsAndConfigs.ticksToPixelRatio, -2*constantsAndConfigs.stafflineGap)
bgItem.setZValue(-10) #This is the z value within GuiTrack
bgItem.setEnabled(False)
transparentBlockHandle = GuiBlockHandle(self, block, 0, -2 * constantsAndConfigs.stafflineGap, block["completeDuration"] / constantsAndConfigs.ticksToPixelRatio, h-constantsAndConfigs.stafflineGap) #x, y, w, h
5 years ago
transparentBlockHandle.color = color
self.transparentBlockHandles.append(transparentBlockHandle)
transparentBlockHandle.setPos(block["tickindex"] / constantsAndConfigs.ticksToPixelRatio, -2*constantsAndConfigs.stafflineGap)
def createStaffLines(self, lengthInPixel = 0):
"""By default creates 5 stafflines. But it can be 10;
5 extra below the origin-staff.
This is NOT a double-system like a piano but just a staff
with more lines that happens to have the range of e.g.
treble + bass clef."""
def createLine(yOffset):
line = QtWidgets.QGraphicsLineItem(QtCore.QLineF(0, 0, lengthInPixel, 0))
line.setParentItem(self)
line.setPen(cosmeticPen)
self.staffLines.append(line)
line.setPos(0, yOffset*constantsAndConfigs.stafflineGap)
line.setZValue(-5) #This is the z value within GuiTrack
for l in self.staffLines:
self.parentScore.removeWhenIdle(l)
self.staffLines = []
lengthInPixel += 25 #a bonus that gives the hint that you can write after the last object.
for i in range(-2, 3): #the normal 5 line system. We have a lower and upper range/position. The middle line is at position 0
createLine(i)
if self.staticExportItem["double"]: #add more stuffs below (user-perspective. positive Qt values)
for i in range(4, 9): #i is now 3. Make a gap:
createLine(i)
def createBarlines(self, barlinesTickList):
"""and measure numbers"""
for bl in self.barLines:
self.parentScore.removeWhenIdle(bl)
self.barLines = []
if self.staticExportItem["double"]:
h = 10 * constantsAndConfigs.stafflineGap
else:
h = 4 * constantsAndConfigs.stafflineGap
#if barlinesTickList[0] == 0: #happens when there is a metrical instruction at tick 0.
# del barlinesTickList[0]
last = None
offset = 0
for barnumber, barlineTick in enumerate(barlinesTickList):
if barlineTick == last:
offset += 1
continue #don't draw the double barline
last = barlineTick
line = QtWidgets.QGraphicsLineItem(QtCore.QLineF(0, 0, 0, h))
line.setParentItem(self)
self.barLines.append(line)
line.setPos(barlineTick / constantsAndConfigs.ticksToPixelRatio, -2*constantsAndConfigs.stafflineGap)
number = QtWidgets.QGraphicsSimpleTextItem(str(barnumber+1-offset))
number.setScale(0.75)
number.setParentItem(line)
number.setPos(-2, -3*constantsAndConfigs.stafflineGap) #-2 on X for a little fine tuning.
def createBeams(self, beamList):
"""This creates the beam-rectangle above/below the stems.
The stems theselves are created in items.py"""
5 years ago
for b in self.beams:
self.parentScore.removeWhenIdle(b)
self.beams = []
for startTick, endTick, beamtype, positionAsStaffline, direction in beamList:
numberOfBeams = int(log(beamtype, 2)-2)
assert numberOfBeams == log(beamtype, 2)-2
for x in range(numberOfBeams):
if direction > 0: #stem/beam upwards
beamNumberOffset = 4*x
xOffset = 7
else:
beamNumberOffset = -4*x
xOffset = 1
#non-scalable X-Offsets are not possible via setPos. zoom and stretch go haywire.
#Instead we use one item for streching for the offset position and wrap it in an item group that is used for positioing.
5 years ago
shifterAnchor = QtWidgets.QGraphicsItemGroup()
shifterAnchor.setParentItem(self)
rectangle = QtWidgets.QGraphicsRectItem(0, 0, (endTick-startTick) / constantsAndConfigs.ticksToPixelRatio, constantsAndConfigs.beamHeight) #x, y, w, h
rectangle.setBrush(QtGui.QColor("black"))
shifterAnchor.addToGroup(rectangle)
shifterAnchor.rectangle = rectangle
rectangle.setPos(xOffset, 0)
#We need the beam no matter the note head mode.
5 years ago
if constantsAndConfigs.noteHeadMode:
rectangle.show()
else:
rectangle.hide()
self.beams.append(shifterAnchor)
x = startTick/ constantsAndConfigs.ticksToPixelRatio
y = beamNumberOffset + positionAsStaffline * constantsAndConfigs.stafflineGap / 2 - 1
shifterAnchor.setPos(x, y)
class TrackAnchor(QtWidgets.QGraphicsItemGroup):
5 years ago
"""Handling all items as individuals when deleting a track to redraw it is too much.
Better let Qt handle it all at once."""
5 years ago
def __init__(self, parent):
super().__init__()
self.parent = parent
def createGraphicItemsFromData(self, staticRepresentationList):
"""Create staff objects including simple barlines"""
self.parentScore.cursor.clearItemHighlight() #or else the current highlight gets deleted while it is on an item
try:
self.parentScore.removeWhenIdle(self.anchor)
except AttributeError: #first round
pass
self.items = []
itemsAppend = self.items.append
self.anchor = GuiTrack.TrackAnchor(self)
self.anchor.setParentItem(self)
metaDataDict = staticRepresentationList.pop()
for staticItem in staticRepresentationList:
item = staticItem2Item(staticItem)
#item.setParentItem(self.anchor)
self.anchor.addToGroup(item)
5 years ago
itemsAppend(item)
item.setPos(item.pixelPosition, 0) # Y axis is set by the position of the track. This sets the position of the whole ItemGroup. The actual pitch of a chord/note is set locally by the chord itself and of no concern here.
item.setZValue(5) #This is the z value within GuiTrack
self.lengthInPixel = metaDataDict["duration"] / constantsAndConfigs.ticksToPixelRatio #this gets updated in stretchXCoordinates
self.createBarlines(metaDataDict["barlines"])
self.createBeams(metaDataDict["beams"])
self.createStaffLines(self.lengthInPixel)
def stretchXCoordinates(self, factor):
"""Reposition the items on the X axis.
Call goes through all parents/children, starting from ScoreView._stretchXCoordinates.
Docstring there."""
#The rects and lines here are just a QGraphicsRectItem and have no custom subclass. So they have no stretchXCoordinates itself.
for item in self.items:
item.setX(item.pos().x() * factor)
item.stretchXCoordinates(factor)
for staticItem in self.staticItems: #labels etc.
staticItem.setX(staticItem.pos().x() * factor)
for barline in self.barLines:
barline.setX(barline.pos().x() * factor)
for staffline in self.staffLines: #stafflines start from x=0. 0*factor=0 so we omit setPos
stretchLine(staffline, factor)
for beam in self.beams: #beams are part of the track, not of the note items.
beam.setX(beam.pos().x() * factor )
stretchRect(beam.rectangle, factor)
for backgroundBlockColor in self.backgroundBlockColors:
backgroundBlockColor.setX(backgroundBlockColor.pos().x() * factor)
stretchRect(backgroundBlockColor, factor)
for transparentBlockHandle in self.transparentBlockHandles:
transparentBlockHandle.setX(transparentBlockHandle.pos().x() * factor)
transparentBlockHandle.stretchXCoordinates(factor)
for ccPath in self.ccPaths.values():
ccPath.stretchXCoordinates(factor)
self.lengthInPixel = self.lengthInPixel * factor #this also gets updated in createGraphicItemsFromData
def itemById(self, itemId):
"""The itemId is the same for backend and gui items. In fact, it is really the
backend-python-object id. But we exported it as static value."""
return next(item for item in self.items if item.staticItem["id"] == itemId)
def blockAt(self, xScenePosition):
for th in self.transparentBlockHandles:
start = th.staticExportItem["tickindex"] / constantsAndConfigs.ticksToPixelRatio
end = start + th.staticExportItem["completeDuration"] / constantsAndConfigs.ticksToPixelRatio
if start <= xScenePosition < end:
return th
return None #After the last block.
def updateMode(self, nameAsString):
"""Modes are opacity based, not show and hide.
This gives us the option that children can ignore the opacity (via qt-flag).
For example we need the block backgrounds to stay visible.
"""
assert nameAsString in constantsAndConfigs.availableEditModes
#We always hide all CC paths and reactivate only a specific one in cc mode later.
for ccPath in self.ccPaths.values():
ccPath.hide()
self.universalCreateFirstCCBlock.hide()
if nameAsString == "notation":
self.setOpacity(1)
for backgroundColor in self.backgroundBlockColors: #created in self.paintBlockBackgroundColors()
backgroundColor.setOpacity(0.2)
for tbh in self.transparentBlockHandles:
tbh.itemMode()
elif nameAsString == "cc":
self.setOpacity(0.1) #the notes can still be seen in the background.
if constantsAndConfigs.ccViewValue in self.ccPaths: #It is not guaranteed that all CC Values have content. On the contrary...
self.ccPaths[constantsAndConfigs.ccViewValue].show()
else:
self.universalCreateFirstCCBlock.show()
for backgroundColor in self.backgroundBlockColors: #created in self.paintBlockBackgroundColors()
backgroundColor.setOpacity(0.2)
for tbh in self.transparentBlockHandles:
tbh.itemMode()
elif nameAsString == "block":
self.setOpacity(0)
for backgroundColor in self.backgroundBlockColors: #simple QRectItems, they don't have their own updateMode function
backgroundColor.setOpacity(1)
for tbh in self.transparentBlockHandles:
tbh.blockMode()