Browse Source

WIP state for tempoTrack undo/redo before change to lazy undo

master
Nils 4 years ago
parent
commit
f040b411b0
  1. 142
      engine/api.py
  2. 680
      engine/ccsubtrack.py
  3. 19
      engine/items.py
  4. 11
      engine/main.py
  5. 743
      engine/tempotrack.py
  6. 16
      engine/track.py
  7. 62
      qtgui/conductor.py
  8. 2
      qtgui/graphs.py
  9. 5
      qtgui/mainwindow.py
  10. 499
      qtgui/timeline.py.delete
  11. 2
      template

142
engine/api.py

@ -38,7 +38,8 @@ from template.helper import flatList, EndlessGenerator
#Our Modules
from . import items
from . import lilypond
from .graphtracks import TempoItem
from .tempotrack import TempoItem, TempoTrack
from .ccsubtrack import GraphItem
from .track import Track
apiModuleSelfReference = sys.modules[__name__]
@ -1979,8 +1980,13 @@ def mergeWithNextGraphBlock(graphBlockId):
#Tempo Track
#TODO: no undo here for various reasons. Many functions auto-delete hidden or overlapping tempo items with no way of currently remembering them.
#history.py says "Better no history than a wrong history." so we clear it, for now.
def _changeTempoTrackBlockAndItemOrder(listWithBlocksData):
"""A helper function for that makes it possible to undo/redo properly. It registers
itself with complementary data as undo/redo."""
orderBeforeInsert = session.data.tempoTrack.putBlockAndItemOrder(listWithBlocksData)
session.history.register(lambda o=orderBeforeInsert: _changeTempoTrackBlockAndItemOrder(o), descriptionString="Tempo Change")
callbacks._updateTempoTrack()
callbacks._historyChanged()
def addTempoItem(blockId, positionInTicksRelativeToBlock, unitsPerMinute, referenceTicks, graphType = "standalone"):
"""blockId includes the track as well as the CC"""
@ -1990,17 +1996,23 @@ def addTempoItem(blockId, positionInTicksRelativeToBlock, unitsPerMinute, refere
return tempoItem
def _addExistingTempoItem(blockId, positionInTicksRelativeToBlock, tempoItem):
tempoBlock = session.data.tempoTrack.tempoBlockById(blockId)
tempoBlock.insert(tempoItem, positionInTicksRelativeToBlock)
session.history.clear() #TODO: overwriting a tempo item does not remember the old one
orderBeforeInsert = session.data.tempoTrack.getBlockAndItemOrder()
tempoBlock = session.data.tempoTrack.tempoBlockById(blockId)
tempoBlock.insert(tempoItem, positionInTicksRelativeToBlock)
session.history.register(lambda o=orderBeforeInsert: _changeTempoTrackBlockAndItemOrder(o), descriptionString="Tempo Change")
callbacks._updateTempoTrack()
callbacks._historyChanged()
def removeTempoItem(tempoItemId):
orderBeforeInsert = session.data.tempoTrack.getBlockAndItemOrder()
tempoBlock, tempoItem = session.data.tempoTrack.tempoItemById(tempoItemId)
tickPositionRelativeToBlockStart = tempoBlock.find(tempoItem)
tempoBlock.remove(tickPositionRelativeToBlockStart)
session.history.clear() # no redo (add item)
session.history.register(lambda o=orderBeforeInsert: _changeTempoTrackBlockAndItemOrder(o), descriptionString="Delete Tempo Change")
callbacks._updateTempoTrack()
callbacks._historyChanged()
def moveTempoItem(tempoItemId, tickPositionAbsolute):
"""Figures out the target block automatically"""
@ -2016,71 +2028,115 @@ def removeCurrentTempoItem():
removeTempoItem(id(tempoItem)) #undo and callback
def changeTempoBlockDuration(tempoBlockId, newDurationInTicks):
tempoBlock = session.data.tempoTrack.tempoBlockById(tempoBlockId)
oldDuration = tempoBlock.duration
tempoBlock.duration = newDurationInTicks
session.history.clear() #resizing to a position of a tempo item in the previous block deletes that tempo item (otherwise there would be 2 items in the same spot). This is not remembered.
callbacks._updateTempoTrack()
def appendTempoBlock():
newBlock = session.data.tempoTrack.appendTempoBlock()
session.history.clear()
"""Can do circular undo/redo"""
tempoBlock = session.data.tempoTrack.tempoBlockById(tempoBlockId)
oldDuration = tempoBlock.duration
session.history.register(lambda i=tempoBlockId, o=oldDuration: changeTempoBlockDuration(i, o), descriptionString="Tempo Block Duration")
callbacks._historyChanged()
tempoBlock.duration = newDurationInTicks
callbacks._updateTempoTrack()
def rearrangeTempoBlocks(listOfBlockIds):
session.history.clear()
"""Can do circular undo/redo. Is used by appendTempoBlock and others"""
oldOrder = session.data.tempoTrack.asListOfBlockIds()
session.history.register(lambda o=oldOrder: rearrangeTempoBlocks(o), descriptionString="Move Tempo Block")
callbacks._historyChanged()
session.data.tempoTrack.rearrangeBlocks(listOfBlockIds)
callbacks._updateTempoTrack()
def changeTempoBlock(tempoBlockId, newParametersDict):
tempoBlock = session.data.tempoTrack.tempoBlockById(tempoBlockId)
session.history.clear()
tempoBlock.putDataFromDict(newParametersDict)
def appendTempoBlock():
oldOrder = session.data.tempoTrack.asListOfBlockIds()
session.history.register(lambda o=oldOrder: rearrangeTempoBlocks(o), descriptionString="Append Tempo Block")
callbacks._historyChanged()
newBlock = session.data.tempoTrack.appendTempoBlock()
callbacks._updateTempoTrack()
def duplicateTempoBlock(tempoBlockId, times = 1):
tempoBlock = session.data.tempoTrack.tempoBlockById(tempoBlockId)
session.history.clear()
oldOrder = session.data.tempoTrack.asListOfBlockIds()
session.history.register(lambda o=oldOrder: rearrangeTempoBlocks(o), descriptionString="Duplicate Tempo Block")
callbacks._historyChanged()
tempoBlock = session.data.tempoTrack.tempoBlockById(tempoBlockId)
for i in range(times):
session.data.tempoTrack.duplicateBlock(tempoBlock)
callbacks._updateTempoTrack()
def duplicateContentLinkTempoBlock(tempoBlockId, times = 1):
"""This is also create content link"""
oldOrder = session.data.tempoTrack.asListOfBlockIds()
session.history.register(lambda o=oldOrder: rearrangeTempoBlocks(o), descriptionString="Duplicate Content Link Tempo Block")
callbacks._historyChanged()
tempoBlock = session.data.tempoTrack.tempoBlockById(tempoBlockId)
session.history.clear()
for i in range(times):
session.data.tempoTrack.duplicateContentLinkBlock(tempoBlock)
callbacks._updateTempoTrack()
def unlinkTempoBlock(tempoBlockId):
def changeTempoBlock(tempoBlockId, newParametersDict):
"""Can do circular undo/redo"""
tempoBlock = session.data.tempoTrack.tempoBlockById(tempoBlockId)
newData, newDuration = tempoBlock.getUnlinkedData()
assert newData, newData
assert newDuration, newDuration
_setTempoBlockData(tempoBlock, newData, newDuration) #handles undo and callbacks
oldParameters = tempoBlock.getDataAsDict()
session.history.register(lambda i=tempoBlockId, o=oldParameters: changeTempoBlock(i, o), descriptionString="Change Tempo Block")
callbacks._historyChanged()
tempoBlock.putDataFromDict(newParametersDict)
callbacks._updateTempoTrack()
def _setTempoBlockData(tempoBlock, newData, newDuration):
"""For undo and redo.
newDuration is the original list with a single integer that may be content linked.
Thats why we get and set the block._duration parameter directly instead of using the setter
.duration."""
session.history.register(lambda bl=tempoBlock, old=tempoBlock.data, dur=tempoBlock._duration: _setTempoBlockData(bl, old, dur), descriptionString = "set tempo black data")
tempoBlock.data = newData
tempoBlock._duration = newDuration
def unlinkTempoBlock(tempoBlockId):
tempoBlock = session.data.tempoTrack.tempoBlockById(tempoBlockId)
if len(tempoBlock.linkedContentBlocks) == 1:
return #This is not a content link block
newData, newLinkedContentBlocks, newDuration = tempoBlock.getUnlinkedData() #does not set itself, just returns
_exchangeTempoBlockData(tempoBlock, newData, newLinkedContentBlocks, newDuration) #handles undo and callbacks
#no callbacks needed.
def _exchangeTempoBlockData(tempoBlock, newData, newLinkedContentBlocks, newDuration):
oldData = tempoBlock.data.copy() #shallow copy. otherwise we can't mix unlink with putBlockAndItemOrder
oldLinkedContentBlocks = tempoBlock.linkedContentBlocks
oldDuration = tempoBlock._duration[:] #shallow copy.
undofunction = lambda: _exchangeTempoBlockData(tempoBlock, oldData, oldLinkedContentBlocks, oldDuration) #flipped around
session.history.register(undofunction, descriptionString="Unlink Tempo Block")
tempoBlock.data = newData
tempoBlock.linkedContentBlocks = newLinkedContentBlocks
tempoBlock._duration = newDuration #mutable list of length 1
for bl in tempoBlock.linkedContentBlocks:
bl.data = newData
bl.linkedContentBlocks = newLinkedContentBlocks
bl._duration = newDuration #mutable list of length 1
callbacks._historyChanged()
callbacks._updateTempoTrack()
def _lazyTempoTrackUndoRedo(new):
old = session.data.tempoTrack.serialize()
session.data.tempoTrack = TempoTrack.instanceFromSerializedData(new, parentData=session.data)
session.history.register(lambda d=old: _lazyTempoTrackUndoRedo(d), descriptionString="Change Tempo Track")
callbacks._historyChanged()
callbacks._updateTempoTrack()
def splitTempoBlock(tempoBlockId, positionInTicksRelativeToBlock:int):
"""tick position is relative to block start"""
"""tick position is relative to block start"""
old = session.data.tempoTrack.serialize()
success = session.data.tempoTrack.splitTempoBlock(tempoBlockId, positionInTicksRelativeToBlock)
if success:
session.history.clear()
if success:
session.history.register(lambda d=old: _lazyTempoTrackUndoRedo(d), descriptionString="Split Tempo Block")
callbacks._updateTempoTrack()
def mergeWithNextTempoBlock(tempoBlockId):
old = session.data.tempoTrack.serialize()
positionForSplit = session.data.tempoTrack.mergeWithNextTempoBlock(tempoBlockId)
session.history.clear() #TODO: merging deletes hidden items in the first block without remembering them for undo
callbacks._updateTempoTrack()
if positionForSplit:
session.history.register(lambda d=old: _lazyTempoTrackUndoRedo(d), descriptionString="Join Tempo Block")
callbacks._historyChanged()
callbacks._updateTempoTrack()
def deleteTempoBlock(tempoBlockId):
tempoBlock = session.data.tempoTrack.tempoBlockById(tempoBlockId)

680
engine/ccsubtrack.py

@ -0,0 +1,680 @@
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright 2019, Nils Hilbricht, Germany ( https://www.hilbricht.net )
This file is part of the Laborejo Software Suite ( https://www.laborejo.org ),
more specifically its template base application.
Laborejo2 is free software: you can redistribute it and/or modify
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; logging.info("import {}".format(__file__))
#Standard Library Modules
from weakref import WeakValueDictionary, WeakSet
#Third Party Modules
from calfbox import cbox
#Template Modules
import template.engine.duration as duration
from template.engine.duration import D1, D4, D1024
from template.helper import pairwise
#Our modules
class GraphItem(object):
"""We use 'CC' here as synonym for whatever int value between 0
and 127, typical 7bit midi values"""
def __init__(self, ccStart):
self.ccStart = ccStart #int
self.graphType = "linear" #options: linear, standalone
self._secondInit(parentBlock = None)
self.lilypondParameters = {}
def _secondInit(self, parentBlock):
"""see Score._secondInit"""
#ignore parentBlock
pass
@classmethod
def instanceFromSerializedData(cls, serializedObject, parentObject):
"""see Score.instanceFromSerializedData"""
assert cls.__name__ == serializedObject["class"]
self = cls.__new__(cls)
self.ccStart = int(serializedObject["ccStart"])
self.graphType = serializedObject["graphType"]
self.lilypondParameters = serializedObject["lilypondParameters"]
self._secondInit(parentBlock = parentObject)
return self
def serialize(self):
result = {}
result["class"] = self.__class__.__name__
result["ccStart"] = self.ccStart
result["graphType"] = self.graphType
result["lilypondParameters"] = self.lilypondParameters
return result
def copy(self):
new = GraphItem(self.ccStart)
new.graphType = self.graphType
new.lilypondParameters = self.lilypondParameters.copy()
return new
def linearRepresentation(self, ccEnd, tickStart, tickEnd):
"""
the variable is taken from the standard formula: f(x) = m*x + n
m = (x2-x1) / (y2-y1)
x1 = tick start
y1 = CC start
x2 = tick end
y2 = CC end
tickStart and tickEnd are absolute values for the complete track
This means we can directly export them to calfbox.
result is tuples (ccValue, tickPOsitionOfThatCCValue)
"""
assert 0 <= self.ccStart < 128
assert 0 <= ccEnd < 128
result = []
if ccEnd == self.ccStart: #there is no interpolation. It is just one value.
result.append((self.ccStart, tickStart))
return result
m = (tickEnd - tickStart) / (ccEnd - self.ccStart) #we need to calculate this after making sure that ccend and start are not the same. Else we get /0
#From here on: We actually need interpolation. Let the math begin.
if ccEnd > self.ccStart: #upward slope
iteratorList = list(range(self.ccStart, ccEnd)) #20 to 70 results in 20....69
else: #downward slope
iteratorList = list(range(ccEnd+1, self.ccStart+1)) #70 to 20 results ins 70...21
iteratorList.reverse()
#Calculate at which tick a given ccValue will happen. value = m * (i - y1)
for ccValue in iteratorList:
result.append((ccValue, tickStart + int(m * (ccValue - self.ccStart)))) # int(m * (ccValue - self.ccStart)) results in 0 for the first item (set by the user). so the first item is just tickStart. that does not mean tickStart for the first item is 0. We just normalize to tickStart as virtual 0 here.
assert result
assert result[0][1] == tickStart
return result
def staticRepresentation(self, ccEnd, tickStart, tickEnd):
if self.graphType == "standalone" or tickEnd < 0 or ccEnd < 0:
result = [(self.ccStart, tickStart)]
elif self.graphType == "linear":
result = self.linearRepresentation(ccEnd, tickStart, tickEnd)
else:
raise ValueError("Graph Type unknown:", self.graphType)
assert result
return result
class GraphBlock(object):
"""Basically a variant of structures.Block, but not for Item type,
but for GraphItem.
Relative to the blocks beginning tick position, handled by the
GraphTrack, in self.data there are:
key = tick position
value = GraphItem
GraphBlocks have a fixed duration. The user has to align them
manually.
"""
firstBlockWithNewContentDuringDeserializeToObject = dict() #this is not resetted anywhere since each load is a program start.
allBlocks = {} #key is the blockId, value is the Block. This is a one way dict. It gets never deleted so undo can recover old blocks. Since blocks are unique this is no problem.
def __init__(self, parentGraphTrack):
self.data = {0:GraphItem(0)} #content linked, mutable.
self.name = str(id(self))
self._duration = [D1*4] #len is always 1. Duration is content linked, thats why it is a mutable list of len==1.
#self.duration = 0 #triggers the setter. in reality this is set to a standard minimum value in def duration
self.linkedContentBlocks = WeakSet() #only new standalone blocks use this empty WeakSet. once you contentLink a block it will be overwritten.
self._secondInit(parentGraphTrack)
def _secondInit(self, parentGraphTrack):
"""see Score._secondInit"""
self.linkedContentBlocks.add(self)
self.rememberBlock()
self.parentGraphTrack = parentGraphTrack
@property
def duration(self):
return self._duration[0]
@duration.setter
def duration(self, newValue):
"""Keep the mutable list at all cost"""
if newValue <= 0:
raise ValueError("duration must be > 1")
listId = id(self._duration)
self._duration.pop()
self._duration.append(newValue)
assert len(self._duration) == 1
assert listId == id(self._duration)
def rememberBlock(self):
oid = id(self)
GraphBlock.allBlocks[oid] = self #This is on the score level, or a global level. That means we don't need to change this, even if the track gets moved to a new track by the api.
#weakref_finalize(self, print, "deleted block "+str(oid))
return oid
@classmethod
def instanceFromSerializedData(cls, serializedObject, parentObject):
"""see Score.instanceFromSerializedData"""
assert cls.__name__ == serializedObject["class"]
self = cls.__new__(cls)
self.parentGraphTrack = parentObject
if serializedObject["data"] is None:
firstBlock = GraphBlock.firstBlockWithNewContentDuringDeserializeToObject[serializedObject["contentLinkGroup"]] #first block with the same contentGroup. This is the one with the real data.
self.data = firstBlock.data
self._duration = firstBlock._duration
self.linkedContentBlocks = firstBlock.linkedContentBlocks #add self to this is in _secondInit
else: #Standalone or First occurence of a content linked block
self.data = {int(position):GraphItem.instanceFromSerializedData(item, parentObject = self) for position, item in serializedObject["data"].items()}
GraphBlock.firstBlockWithNewContentDuringDeserializeToObject[serializedObject["contentLinkGroup"]] = self
self.linkedContentBlocks = WeakSet()
self._duration = [int(serializedObject["duration"])] #this is just an int, minimumBlockInTicks or so. Not Item.Duration(). For save and load we drop the list as mutable value.
self.name = serializedObject["name"]
self._secondInit(parentObject)
return self
def serialize(self):
result = {}
result["class"] = self.__class__.__name__
result["name"] = self.name
result["duration"] = self.duration #this is just an int, minimumBlockInTicks or so. Not Item.Duration(). For save and load we drop the list as mutable value.
#We only save the data if this is the first content-linked block in a sequence.
contentLinkGroupId = id(self.data)
result["contentLinkGroup"] = contentLinkGroupId
for block in self.parentGraphTrack.blocks:
blockId = id(block)
dataId = id(block.data)
if dataId == contentLinkGroupId:
if blockId == id(self): #first block with this dataId found.
result["data"] = {int(itemTickPosition):item.serialize() for itemTickPosition, item in self.data.items()}
else: #content linked, but not the first. Block already serialized.
result["data"] = None #we don't need to do anything more. The rest is handled by load and instanceFromSerializedData
break
else:
raise StopIteration("self block not found in graphTrack.blocks")
#loop ran through. This never happens.
return result
def getDataAsDict(self):
return { "name" : self.name,
"duration" : self.duration,
}
def putDataFromDict(self, dataDict):
"""modify inplace. Useful for a gui function. Compatible with
the data from getDataAsDict"""
self.name = dataDict["name"]
self.duration = dataDict["duration"]
def copy(self):
"""Return an independet copy of this block."""
new = type(self)(parentGraphTrack = self.parentGraphTrack)
assert len(new.linkedContentBlocks) == 1 #even a copy of a linked block becomes a stand-alone copy
for itemTickPosition, item in self.data.items():
new.data[itemTickPosition] = item.copy()
if self.name.endswith("-copy"):
new.name = self.name
else:
new.name = self.name + "-copy"
new._duration = self._duration[:] #mutable
return new
def contentLink(self):
"""Return a copy where only certain parameters
like Content are linked. Others can be changed"""
new = type(self)(parentGraphTrack = self.parentGraphTrack)
new.linkedContentBlocks = self.linkedContentBlocks
new.linkedContentBlocks.add(new)
new.data = self.data #mutable
new.name = self.name
new._duration = self._duration #mutable
return new
def getUnlinkedData(self):
"""Set and handled for undo/redo by the api.
This function does not unlink itself but needs
the api. Instead we return new independent data."""
newData = {}
linkedContentBlocks = WeakSet()
linkedContentBlocks.add(self)
for itemTickPosition, item in self.data.items(): #deep copy
copy = item.copy()
newData[itemTickPosition] = copy
return newData, linkedContentBlocks, self._duration[:] #mutable. the api uses the list directly as well because we want to undo/restore the old original list, which may be content linked.
def linkedContentBlocksInScore(self):
"""Named for compatibility with structures block.
Added a safety net to make sure only blocks which are actually in the timeline will be
returned. Not those in the undo buffer.
The return is sorted to be in the actual track order.
"""
assert len(self.linkedContentBlocks) >= 1
blocksInTrack = [block for block in self.linkedContentBlocks if block.parentGraphTrack]
ordered = sorted(blocksInTrack, key = lambda block: self.parentGraphTrack.blocks.index(block))
return ordered
def insert(self, graphItem, tickPositionRelativeToBlockStart):
self.data[tickPositionRelativeToBlockStart] = graphItem
return True #cannot fail, for now. the api still waits for a positive return code
def find(self, graphItem):
"""find a relative tick position by graphItem.
We already know that the graphItem is in this block. Now we
need to find the position."""
assert graphItem in self.data.values()
for position, item in self.data.items():
if item is graphItem:
return position
else:
raise ValueError("graphItem not found in this block", graphItem, self)
def remove(self, tickPositionRelativeToBlockStart):
if not tickPositionRelativeToBlockStart == 0: #don't allow the first item in a block to be deleted. Since the 0 item can't be moved this will always be the 0 item.
assert tickPositionRelativeToBlockStart != min(self.data.keys()) #this can't be the first item in this block.
del self.data[tickPositionRelativeToBlockStart]
return True
return False
def move(self, tickPositionRelativeToBlockStart, newPosition):
"""we don't allow the first item to be moved. Makes
things easier and clearer for the user"""
if tickPositionRelativeToBlockStart > 0 and not tickPositionRelativeToBlockStart == newPosition: #otherwise it would just delete the complete item because old and new are the same and there would be no duplicate item to delete.
self.data[newPosition] = self.data[tickPositionRelativeToBlockStart]
del self.data[tickPositionRelativeToBlockStart]
def deleteHiddenItems(self):
if self.getMaxContentPosition() > self.duration:
toDelete = [pos for pos in self.data.keys() if pos > self.duration] #must be list, not generator, because we need the positions in advance to delete them later. A generator would delete from the dict while it is still generated.
for delPos in toDelete:
del self.data[delPos]
def exportsAllItems(self):
"""Does the current self.duration prevent GraphItems from
getting exported?"""
if max(self.data) > self.duration:
return False
else:
return True
def getMaxContentPosition(self):
value = max(sorted(self.data.keys()))
return value
def staticRepresentation(self):
"""list of (tickPositionRelativeToBlockStart, GraphItem) tuples.
Only exports items which fit into this blocks duration."""
sortedListOfTuples = []
for tickPosition, graphItem in self.data.items():
if tickPosition <= self.duration:
sortedListOfTuples.append((tickPosition, graphItem))
sortedListOfTuples.sort()
return sortedListOfTuples
def extendToTrackLength(self, myParentCCTrack):
"""This is a user-called command intended for the last block
in a track
Why not extend the last block automatically?
First these are too many updates so performance goes down.
Second it confuses the user when he/she attempts to split
or append. Especially append.
"""
assert self is myParentCCTrack.blocks[-1]
plainScoreDuration = myParentCCTrack.score.duration()
durationWithoutLastBlock = myParentCCTrack.durationWithoutLastBlock()
#print ("score:", plainScoreDuration, "allOther", TempoBlock.tempoTrack.durationWithoutLastBlock())
if plainScoreDuration > 0 and plainScoreDuration > durationWithoutLastBlock:
self.duration = plainScoreDuration - durationWithoutLastBlock
class GraphTrackCC(object):
"""A track for midi Control Changes.
There is no cursor and no state. Just a sequence of blocks.
The actual CC value comes from the track."""
def __init__(self, cc, parentTrack):
firstBlock = GraphBlock(parentGraphTrack = self)
self.blocks = [firstBlock] #there is always at least one block.
self.cc = cc
self._secondInit(parentTrack = parentTrack)
def _secondInit(self, parentTrack):
"""see Score._secondInit"""
self.parentTrack = parentTrack
@classmethod
def instanceFromSerializedData(cls, serializedObject, parentObject):
"""see Score.instanceFromSerializedData"""
assert cls.__name__ == serializedObject["class"]
self = cls.__new__(cls)
self.cc = int(serializedObject["cc"])
self.blocks = [GraphBlock.instanceFromSerializedData(block, parentObject = self) for block in serializedObject["blocks"]]
self._secondInit(parentTrack = parentObject)
return self
def serialize(self):
result = {}
result["class"] = self.__class__.__name__
result["cc"] = self.cc
result["blocks"] = [block.serialize() for block in self.blocks]
return result
def durationWithoutLastBlock(self):
result = 0
for block in self.blocks[:-1]: #returns empty list when only one block in self.blocks. So no loop will happen and this function returns 0
result += block.duration
return result
def asListOfBlockIds(self):
"""Return an ordered list of block ids"""
return [id(block) for block in self.blocks]
def appendGraphBlock(self):
"""A simple method to add a new GraphBlock at the end of the
current track. Basically you can do the same with split and
resize, but this is much more easier."""
new = GraphBlock(parentGraphTrack = self)
return self.appendExistingGraphBlock(new)
def appendExistingGraphBlock(self, graphBlock):
self.blocks.append(graphBlock)
return graphBlock
def splitGraphBlock(self, graphBlock, positionInTicksRelativeToBlock):
"""The new block will be right of the original content. If the new block will be empty
or has no real start value the last prevailing value will be used
as the blocks start-point"""
#TODO: refactoring. This is bascially a copy of splitTempoBlock except the block is not an id here. And the name.
block = graphBlock
assert block.duration > positionInTicksRelativeToBlock
hasPointAtZero = False
toDelete = []
modelNewBlock = GraphBlock(parentGraphTrack = self) #will not be used directly, but instead content links will be created.
for pos, item in block.data.items():
#Determine if a ccPoint gets to move to the new block
if pos >= positionInTicksRelativeToBlock:
if pos == positionInTicksRelativeToBlock:
hasPointAtZero = True
modelNewBlock.data[pos - positionInTicksRelativeToBlock] = item
toDelete.append(pos)
#else: ccPoint stays in the old block
for pos in toDelete:
del block.data[pos]
#Since every block comes with a value at position 0 we need to check if this was already replaced or if we need to adjust it to the real tempo at this point in time.
if not hasPointAtZero:
realStartCCPoint = block.data[block.getMaxContentPosition()] #only the remaining items.
modelNewBlock.data[0] = realStartCCPoint.copy()
#Now the original block and all its content links have fewer items than before
#For every of the content-linked blocks in the tempo track we need to create a new block and insert it right next to it.
for bl in block.linkedContentBlocksInScore():
index = self.blocks.index(bl)
link = modelNewBlock.contentLink()
self.blocks.insert(index +1, link)
#duration is mutable. All content links change duration as well.
link.duration = block.duration - positionInTicksRelativeToBlock
block.duration = positionInTicksRelativeToBlock
del GraphBlock.allBlocks[id(modelNewBlock)] #Clean up the model block since it was never intended to go into the TempoTrack
return True
def mergeWithNextGraphBlock(self, graphBlock):
"""see structures block (the music block) for an explanation about merging content linked
blocks.
Hidden items (after the current duration value) of the original block
will be deleted. Hidden items of the follow-up block will be merged, but stay hidden.
"""
#TODO: refactoring. This is bascially a copy of splitTempoBlock except the block is not an id here. And the name.
block = graphBlock
if len(self.blocks) == 1:
#print ("only one block in the track")
return False
blockIndex = self.blocks.index(block)
if blockIndex+1 == len(self.blocks):
#print ("not for the last block")
return False
nextIndex = blockIndex + 1
nextBlock = self.blocks[nextIndex]
firstBlock_endingValue = block.data[block.getMaxContentPosition()].ccStart
nextBlock_startingValue = nextBlock.data[0].ccStart
startDurationToReturnForUndo = block.duration
if len(block.linkedContentBlocksInScore()) == 1 and len(nextBlock.linkedContentBlocksInScore()) == 1: #both blocks are standalone. no content-links. This also prevents that both blocks are content links of each other.
block.deleteHiddenItems()
if firstBlock_endingValue == nextBlock_startingValue: #remove redundancy
del nextBlock.data[0]
for pos, item in nextBlock.data.items():
assert not pos + block.duration in block.data
block.data[pos + block.duration] = item
block.duration += nextBlock.duration
self.deleteBlock(nextBlock)
return startDurationToReturnForUndo
elif len(block.linkedContentBlocksInScore()) == len(nextBlock.linkedContentBlocksInScore()): #It is maybe possible to build pairs from the current block and all its content links with the follow up block and all its content links.
#Further testing required:
for firstBlock, secondBlock in zip(block.linkedContentBlocksInScore(), nextBlock.linkedContentBlocksInScore()):
if firstBlock.data is secondBlock.data: #content link of itself in succession. Very common usecase, but not compatible with merging.
#print ("content link follows itself")
return False
elif not self.blocks.index(firstBlock) + 1 == self.blocks.index(secondBlock): #all first blocks must be followed directly by a content link of the second block. linkedContentBlocksInScore() returns a blocklist in order so we can compare.
#print ("not all blocks-pairs are next to each other")
return False
#Test complete without exit. All blocks can be paired up.
#print ("Test complete. Merging begins")
block.deleteHiddenItems()
if firstBlock_endingValue == nextBlock_startingValue: #remove redundancy
del nextBlock.data[0]
for pos, item in nextBlock.data.items():
assert not pos + block.duration in block.data #this includes pos==0, if not deleted above.
block.data[pos + block.duration] = item
def deleteBlock(self, graphBlock):
"""at least one block. If you want to delete the track
use api.deleteGraphTrackCC"""
if len(self.blocks) > 1:
graphBlock.parentGraphTrack = None
self.blocks.remove(graphBlock)
return graphBlock
def duplicateBlock(self, graphBlock):
index = self.blocks.index(graphBlock)
copy = graphBlock.copy()
self.blocks.insert(index +1, copy)
def duplicateContentLinkBlock(self, graphBlock):
index = self.blocks.index(graphBlock)
linked = graphBlock.contentLink()
self.blocks.insert(index +1, linked)
def blocksAsDict(self):
"""Key is the block id, value the block instance"""
result = {}
for block in self.blocks:
result[id(block)] = block
return result
def rearrangeBlocks(self, listOfBlockIds):
"""Reorder the blocks in this track.
Achtung! Not including a block will delete this block
This is not allowed so we check for it."""
#blocksDict = self.blocksAsDict()
newBlockArrangement = []
for idLong in listOfBlockIds:
#newBlockArrangement.append(blocksDict[idLong])
newBlockArrangement.append(GraphBlock.allBlocks[idLong]) #all blocks includes deleted blocks in the undo memory.
#a block is a unique unit in Laborejo2. Let's make sure there are no duplicates.
#http://stackoverflow.com/questions/480214/how-do-you-remove-duplicates-from-a-list-in-python-whilst-preserving-order
seen = set()
seen_add = seen.add
self.blocks = [ x for x in newBlockArrangement if x not in seen and not seen_add(x)]
assert self.blocks
def staticRepresentation(self):
typeString = ""
sumOfBlocksDurationsWithoutCurrent = 0
result = []
patternBlob = bytes() # Create a binary blob that contains the MIDI events for CC tracks
self.cleanBlockEdges()
for blockIndex in range(len(self.blocks)):
block = self.blocks[blockIndex]
assert len(block.data) > 0
l = block.staticRepresentation() #this takes care that only user items which fit in the block.duration are exported.
for itemIndex in range(len(l)): #range starts from 0 so we can use this as index.
#l has tuples (tickPositionFromBlockStart, GraphItem)
thisPosition = l[itemIndex][0]
thisGraphItem = l[itemIndex][1]
#Check if we reached the last item in this block.
if itemIndex is len(l)-1: #len counts from 1, itemIndex from 0.
assert thisGraphItem is l[-1][1] #l[-1] is a tuple (tickPositionFromBlockStart, GraphItem)
#Is there another block after this one?
if block is self.blocks[-1]: #this was the last block?
#there is no nextGraphItem and subsequently no interpolation.
typeString = "lastInTrack" # also a switch for later.
nextPosition = -1 #doesn't matter
#this is checked later in the loop, before we create the exportDict
else: #there is still a block left after the current
#The nextGraphItem can be found in the next block.
nextBlock = self.blocks[blockIndex+1]
nextBlockL = nextBlock.staticRepresentation()
nextPosition = nextBlockL[0][0] + block.duration #Instead of itemIndex we just need [0] for the first in the next block.
nextGraphItem = nextBlockL[0][1] #Instead of itemIndex we just need [0] for the first
else: #default case. Next item is still in the same block.
nextPosition = l[itemIndex+1][0]
nextGraphItem = l[itemIndex+1][1]
#We now generate a chain of items from the current position to the next,
#at least one, depending on the interpolation type (like linear, none etc.)
if typeString == "lastInTrack":
userItemAndInterpolatedItemsPositions = thisGraphItem.staticRepresentation(-1, thisPosition, -1) #-1 are magic markers that indicate a forced standalone mode. no interpolation, we just get one item back.
else:
assert thisPosition >= 0
assert nextPosition >= 0
typeString = "user" #interpolated, lastInTrack
userItemAndInterpolatedItemsPositions = thisGraphItem.staticRepresentation(nextGraphItem.ccStart, thisPosition, nextPosition)
for ccValue, generatedTickPosition in userItemAndInterpolatedItemsPositions: #generatedTickPosition is relative to the block beginning.
if typeString == "user" or typeString == "lastInTrack": #interpolated items can be anywhere. We don't care much about them.
assert generatedTickPosition <= block.duration
assert 127 >= ccValue >= 0
assert generatedTickPosition >= 0
exportDictItem = {
"type" : typeString,
"value": -1*ccValue, #minus goes up because it reduces the line position, which starts from top of the screen. For a tempo this is a bpm value for quarter notes.
"position" : sumOfBlocksDurationsWithoutCurrent + generatedTickPosition, #generatedTickPosition is relative to the block beginning.
"id" : id(thisGraphItem),
"blockId": id(block),
"minPossibleAbsolutePosition" : sumOfBlocksDurationsWithoutCurrent, #If you want to move this item to the left or right, this is only possible within the current block.
"maxPossibleAbsolutePosition" : sumOfBlocksDurationsWithoutCurrent + block.duration, #If you want to move this item to the left or right, this is only possible within the current block.
"lastInBlock" : len(block.data) == 1,
}
result.append(exportDictItem)
typeString = "interpolated" #The next items in userItemAndInterpolatedItemsPositions are interpolated items. Reset once we leave the local forLoop.
#numbers from 0-15 which represent the midi channels all CCs are sent to. Only replaced by a new tuple by the user directly.
if self.parentTrack.ccChannels:
for channel in self.parentTrack.ccChannels:
blob = cbox.Pattern.serialize_event(exportDictItem["position"], 0xB0 + channel, self.cc, ccValue) #position, status byte+channel, controller number, controller value #TODO use channel of the parent note track at that moment in time.
patternBlob += blob
else: #If empty then CC uses the tracks initial midi channel.
blob = cbox.Pattern.serialize_event(exportDictItem["position"], 0xB0 + self.parentTrack.initialMidiChannel, self.cc, ccValue) #position, status byte+channel, controller number, controller value #TODO use channel of the parent note track at that moment in time.
patternBlob += blob
#Prepare data for the next block.
sumOfBlocksDurationsWithoutCurrent += block.duration #the naming is only true until the last iteration. Then all blocks, even the current one, are in the sum and can be used below.
sumOfBlockDurations = sumOfBlocksDurationsWithoutCurrent #Choose the correct name. Explicit is better than implicit.
#if sumOfBlockDurations > 0:
self.parentTrack.sequencerInterface.setSubtrack(key=self.cc, blobs=[(patternBlob, 0, sumOfBlockDurations),]) #(bytes-blob, position, length)
return result
def staticGraphBlocksRepresentation(self):
"""Return a sorted list"""
result = []
tickCounter = 0
for block in self.blocks:
result.append({"type" : "GraphBlock", "id":id(block), "name":block.name, "duration":block.duration, "position":tickCounter, "exportsAllItems":block.exportsAllItems()})
tickCounter += block.duration
return result
def staticTrackRepresentation(self):
result = {}
return result
def graphItemById(self, graphItemId):
for graphBlock in self.blocks:
for tickPosition, graphItem in graphBlock.staticRepresentation(): # a list of tuples
if id(graphItem) == graphItemId:
return graphBlock, graphItem
else:
raise ValueError("graphItemId not found in this track", graphItemId)
def cleanBlockEdges(self):
"""If a first block has an item at tick 300 and a second block is resized to begin at
tick 300 as well then the last item and the start-item are in the same spot.
The last item needs to go away."""
for block in self.blocks:
if block.getMaxContentPosition() == block.duration:
block.remove(block.duration)

19
engine/items.py

@ -715,10 +715,10 @@ class Item(object):
export basis. For example for GUI frontends. They don't have to
parse and calculate their own values in slow pure Python then
midiBytes is a list with pblob/binary data generated by
midiBytes is a list with patternBlob/binary data generated by
cbox.Pattern.serialize_event(position, midibyte1 (noteon), midibyte2(pitch), midibyte3(velocity))
Items with duration, like chords, will most like need to create
at least two pblobs, one for the start (e.g. note on) and one
at least two patternBlobs, one for the start (e.g. note on) and one
for the stop (e.g. note off)
"""
raise NotImplementedError("Implement _exportObject() for this item type!")
@ -887,10 +887,10 @@ class TemplateItem(Item):
export basis. For example for GUI frontends. They don't have to
parse and calculate their own values in slow pure Python then
midiBytes is a list with pblob/binary data generated by
midiBytes is a list with patternBlob/binary data generated by
cbox.Pattern.serialize_event(position, midibyte1 (noteon), midibyte2(pitch), midibyte3(velocity))
Items with duration, like chords, will most like need to create
at least two pblobs, one for the start (e.g. note on) and one
at least two patternBlobs, one for the start (e.g. note on) and one
for the stop (e.g. note off)
"""
raise NotImplementedError("Implement _exportObject() for this item type!")
@ -2669,6 +2669,13 @@ class InstrumentChange(Item):
"UIstring" : "{}[pr{}{}{}]".format(_nameStr, self.program, _msbStr, _lsbStr), #this is for a UI, possibly a text UI, maybe for simple items of a GUI. Make it as short and unambigious as possible.
}
#hier weiter machen. die midiBytes können so exportiert werden, wahrscheinlich auch auf diesem channel.
#Aber die müssen im Track dann am Ende rausgefiltert werden und auf einen eigenen cbox midi track.
#Die Alternative wäre das aufzuteilen. Eins auf CC0, eins auf CC32 und der Program Change auf einen eigenen Kanal?
#Was ist mit sowas wie initial program? Wo wird das geändert? In den Track Properties. Vielleichst ist das selbst ein InstrumentChange Objekt. Könnte eins sein zumindest.
def _lilypond(self):
"""called by block.lilypond(), returns a string.
Don't create white-spaces yourself, this is done by the structures.
@ -2794,10 +2801,10 @@ class RecordedNote(Item):
export basis. For example for GUI frontends. They don't have to
parse and calculate their own values in slow pure Python then
midiBytes is a list with pblob/binary data generated by
midiBytes is a list with patternBlob/binary data generated by
cbox.Pattern.serialize_event(position, midibyte1 (noteon), midibyte2(pitch), midibyte3(velocity))
Items with duration, like chords, will most like need to create
at least two pblobs, one for the start (e.g. note on) and one
at least two patternBlobs, one for the start (e.g. note on) and one
for the stop (e.g. note off)
"""
raise NotImplementedError("Implement _exportObject() for this item type!")

11
engine/main.py

@ -34,8 +34,7 @@ import template.engine.sequencer
from .block import Block
from .track import Track
from .cursor import Cursor
from. graphtracks import TempoTrack
from .tempotrack import TempoTrack
class Data(template.engine.sequencer.Score):
@ -261,11 +260,8 @@ class Data(template.engine.sequencer.Score):
self.currentTrack().goToTickindex(nowInTicks)
def cursorExport(self):
try:
return self.cursor.exportObject(self.currentTrack().state)
except ValueError: #debugging without callbacks
warn("cursor export did not work. If this was during debugging without callbacks it is allright.")
return {}
return self.cursor.exportObject(self.currentTrack().state)
def _cursorExportTrackTick(self, track, tickPosition):
originalPosition = track.state.position()
@ -737,7 +733,6 @@ class Data(template.engine.sequencer.Score):
putBlockAndItemOrder. It looks for true changes itself
and returns a list of trackIDs that need callback updates.
No blocks will be deleted or replaced with this because
deleteSelection leaves empty blocks and paste is not capable
of creating new blocks.

743
engine/graphtracks.py → engine/tempotrack.py

@ -28,670 +28,11 @@ from weakref import WeakValueDictionary, WeakSet
#Third Party Modules
#Template Modules
import template.engine.duration as duration
from template.engine.duration import D1, D4, D1024
from template.helper import pairwise
#Our modules
from .ccsubtrack import GraphTrackCC, GraphBlock
class GraphItem(object):
"""We use 'CC' here as synonym for whatever int value between 0
and 127, typical 7bit midi values"""
def __init__(self, ccStart):
self.ccStart = ccStart #int
self.graphType = "linear" #options: linear, standalone
self._secondInit(parentBlock = None)
self.lilypondParameters = {}
def _secondInit(self, parentBlock):
"""see Score._secondInit"""
#ignore parentBlock
pass
@classmethod
def instanceFromSerializedData(cls, serializedObject, parentObject):
"""see Score.instanceFromSerializedData"""
assert cls.__name__ == serializedObject["class"]
self = cls.__new__(cls)
self.ccStart = int(serializedObject["ccStart"])
self.graphType = serializedObject["graphType"]
self.lilypondParameters = serializedObject["lilypondParameters"]
self._secondInit(parentBlock = parentObject)
return self
def serialize(self):
result = {}
result["class"] = self.__class__.__name__
result["ccStart"] = self.ccStart
result["graphType"] = self.graphType
result["lilypondParameters"] = self.lilypondParameters
return result
def copy(self):
new = GraphItem(self.ccStart)
new.graphType = self.graphType
new.lilypondParameters = self.lilypondParameters.copy()
return new
def linearRepresentation(self, ccEnd, tickStart, tickEnd):
"""
the variable is taken from the standard formula: f(x) = m*x + n
m = (x2-x1) / (y2-y1)
x1 = tick start
y1 = CC start
x2 = tick end
y2 = CC end
tickStart and tickEnd are absolute values for the complete track
This means we can directly export them to calfbox.
result is tuples (ccValue, tickPOsitionOfThatCCValue)
"""
assert 0 <= self.ccStart < 128
assert 0 <= ccEnd < 128
result = []
if ccEnd == self.ccStart: #there is no interpolation. It is just one value.
result.append((self.ccStart, tickStart))
return result
m = (tickEnd - tickStart) / (ccEnd - self.ccStart) #we need to calculate this after making sure that ccend and start are not the same. Else we get /0
#From here on: We actually need interpolation. Let the math begin.
if ccEnd > self.ccStart: #upward slope
iteratorList = list(range(self.ccStart, ccEnd)) #20 to 70 results in 20....69
else: #downward slope
iteratorList = list(range(ccEnd+1, self.ccStart+1)) #70 to 20 results ins 70...21
iteratorList.reverse()
#Calculate at which tick a given ccValue will happen. value = m * (i - y1)
for ccValue in iteratorList:
result.append((ccValue, tickStart + int(m * (ccValue - self.ccStart)))) # int(m * (ccValue - self.ccStart)) results in 0 for the first item (set by the user). so the first item is just tickStart. that does not mean tickStart for the first item is 0. We just normalize to tickStart as virtual 0 here.
assert result
assert result[0][1] == tickStart
return result
def staticRepresentation(self, ccEnd, tickStart, tickEnd):
if self.graphType == "standalone" or tickEnd < 0 or ccEnd < 0:
result = [(self.ccStart, tickStart)]
elif self.graphType == "linear":
result = self.linearRepresentation(ccEnd, tickStart, tickEnd)
else:
raise ValueError("Graph Type unknown:", self.graphType)
assert result
return result
class GraphBlock(object):
"""Basically a variant of structures.Block, but not for Item type,
but for GraphItem.
Relative to the blocks beginning tick position, handled by the
GraphTrack, in self.data there are:
key = tick position
value = GraphItem
GraphBlocks have a fixed duration. The user has to align them
manually.
"""
firstBlockWithNewContentDuringDeserializeToObject = dict() #this is not resetted anywhere since each load is a program start.
allBlocks = {} #key is the blockId, value is the Block. This is a one way dict. It gets never deleted so undo can recover old blocks. Since blocks are unique this is no problem.
def __init__(self, parentGraphTrack):
self.data = {0:GraphItem(0)} #content linked, mutable.
self.name = str(id(self))
self._duration = [D1*4] #len is always 1. Duration is content linked, thats why it is a mutable list of len==1.
#self.duration = 0 #triggers the setter. in reality this is set to a standard minimum value in def duration
self.linkedContentBlocks = WeakSet() #only new standalone blocks use this empty WeakSet. once you contentLink a block it will be overwritten.
self._secondInit(parentGraphTrack)
def _secondInit(self, parentGraphTrack):
"""see Score._secondInit"""
self.linkedContentBlocks.add(self)
self.rememberBlock()
self.parentGraphTrack = parentGraphTrack
@property
def duration(self):
return self._duration[0]
@duration.setter
def duration(self, newValue):
"""Keep the mutable list at all cost"""
if newValue <= 0:
raise ValueError("duration must be > 1")
listId = id(self._duration)
self._duration.pop()
self._duration.append(newValue)
assert len(self._duration) == 1
assert listId == id(self._duration)
def rememberBlock(self):
oid = id(self)
GraphBlock.allBlocks[oid] = self #This is on the score level, or a global level. That means we don't need to change this, even if the track gets moved to a new track by the api.
#weakref_finalize(self, print, "deleted block "+str(oid))
return oid
@classmethod
def instanceFromSerializedData(cls, serializedObject, parentObject):
"""see Score.instanceFromSerializedData"""
assert cls.__name__ == serializedObject["class"]
self = cls.__new__(cls)
self.parentGraphTrack = parentObject
if serializedObject["data"] is None:
firstBlock = GraphBlock.firstBlockWithNewContentDuringDeserializeToObject[serializedObject["contentLinkGroup"]] #first block with the same contentGroup. This is the one with the real data.
self.data = firstBlock.data
self._duration = firstBlock._duration
self.linkedContentBlocks = firstBlock.linkedContentBlocks #add self to this is in _secondInit
else: #Standalone or First occurence of a content linked block
self.data = {int(position):GraphItem.instanceFromSerializedData(item, parentObject = self) for position, item in serializedObject["data"].items()}
GraphBlock.firstBlockWithNewContentDuringDeserializeToObject[serializedObject["contentLinkGroup"]] = self
self.linkedContentBlocks = WeakSet()
self._duration = [int(serializedObject["duration"])] #this is just an int, minimumBlockInTicks or so. Not Item.Duration(). For save and load we drop the list as mutable value.
self.name = serializedObject["name"]
self._secondInit(parentObject)
return self
def serialize(self):
result = {}
result["class"] = self.__class__.__name__
result["name"] = self.name
result["duration"] = self.duration #this is just an int, minimumBlockInTicks or so. Not Item.Duration(). For save and load we drop the list as mutable value.
#We only save the data if this is the first content-linked block in a sequence.
contentLinkGroupId = id(self.data)
result["contentLinkGroup"] = contentLinkGroupId
for block in self.parentGraphTrack.blocks:
blockId = id(block)
dataId = id(block.data)
if dataId == contentLinkGroupId:
if blockId == id(self): #first block with this dataId found.
result["data"] = {int(itemTickPosition):item.serialize() for itemTickPosition, item in self.data.items()}
else: #content linked, but not the first. Block already serialized.
result["data"] = None #we don't need to do anything more. The rest is handled by load and instanceFromSerializedData
break
else:
raise StopIteration("self block not found in graphTrack.blocks")
#loop ran through. This never happens.
return result
def getDataAsDict(self):
return { "name" : self.name,
"duration" : self.duration,
}
def putDataFromDict(self, dataDict):
"""modify inplace. Useful for a gui function. Compatible with
the data from getDataAsDict"""
self.name = dataDict["name"]
self.duration = dataDict["duration"]
def copy(self):
"""Return an independet copy of this block."""
new = type(self)(parentGraphTrack = self.parentGraphTrack)
assert len(new.linkedContentBlocks) == 1 #even a copy of a linked block becomes a stand-alone copy
for itemTickPosition, item in self.data.items():
new.data[itemTickPosition] = item.copy()
if self.name.endswith("-copy"):
new.name = self.name
else:
new.name = self.name + "-copy"
new._duration = self._duration[:] #mutable
return new
def contentLink(self):
"""Return a copy where only certain parameters
like Content are linked. Others can be changed"""
new = type(self)(parentGraphTrack = self.parentGraphTrack)
new.linkedContentBlocks = self.linkedContentBlocks
new.linkedContentBlocks.add(new)
new.data = self.data
new.name = self.name
new._duration = self._duration #mutable
return new
def getUnlinkedData(self):
"""Set and handled for undo/redo by the api"""
newData = {}
linkedContentBlocks = WeakSet()
linkedContentBlocks.add(self)
for itemTickPosition, item in self.data.items():
copy = item.copy()
newData[itemTickPosition] = copy
copy.linkedContentBlocks = linkedContentBlocks
return newData, self._duration[:] #mutable. the api uses the list directly as well because we want to undo/restore the old original list, which may be content linked.
def linkedContentBlocksInScore(self):
"""Named for compatibility with structures block.
Added a safety net to make sure only blocks which are actually in the timeline will be
returned. Not those in the undo buffer.
The return is sorted to be in the actual track order.
"""
assert len(self.linkedContentBlocks) >= 1
blocksInTrack = [block for block in self.linkedContentBlocks if block.parentGraphTrack]
ordered = sorted(blocksInTrack, key = lambda block: self.parentGraphTrack.blocks.index(block))
return ordered
def insert(self, graphItem, tickPositionRelativeToBlockStart):
self.data[tickPositionRelativeToBlockStart] = graphItem
return True #cannot fail, for now. the api still waits for a positive return code
def find(self, graphItem):
"""find a relative tick position by graphItem.
We already know that the graphItem is in this block. Now we
need to find the position."""
assert graphItem in self.data.values()
for position, item in self.data.items():
if item is graphItem:
return position
else:
raise ValueError("graphItem not found in this block", graphItem, self)
def remove(self, tickPositionRelativeToBlockStart):
if not tickPositionRelativeToBlockStart == 0: #don't allow the first item in a block to be deleted. Since the 0 item can't be moved this will always be the 0 item.
assert tickPositionRelativeToBlockStart != min(self.data.keys()) #this can't be the first item in this block.
del self.data[tickPositionRelativeToBlockStart]
return True
return False
def move(self, tickPositionRelativeToBlockStart, newPosition):
"""we don't allow the first item to be moved. Makes
things easier and clearer for the user"""
if tickPositionRelativeToBlockStart > 0 and not tickPositionRelativeToBlockStart == newPosition: #otherwise it would just delete the complete item because old and new are the same and there would be no duplicate item to delete.
self.data[newPosition] = self.data[tickPositionRelativeToBlockStart]
del self.data[tickPositionRelativeToBlockStart]
def deleteHiddenItems(self):
if self.getMaxContentPosition() > self.duration:
toDelete = [pos for pos in self.data.keys() if pos > self.duration] #must be list, not generator, because we need the positions in advance to delete them later. A generator would delete from the dict while it is still generated.
for delPos in toDelete:
del self.data[delPos]
def exportsAllItems(self):
"""Does the current self.duration prevent GraphItems from
getting exported?"""
if max(self.data) > self.duration:
return False
else:
return True
def getMaxContentPosition(self):
value = max(sorted(self.data.keys()))
return value
def staticRepresentation(self):
"""list of (tickPositionRelativeToBlockStart, GraphItem) tuples.
Only exports items which fit into this blocks duration."""
sortedListOfTuples = []
for tickPosition, graphItem in self.data.items():
if tickPosition <= self.duration:
sortedListOfTuples.append((tickPosition, graphItem))
sortedListOfTuples.sort()
return sortedListOfTuples
def extendToTrackLength(self, myParentCCTrack):
"""This is a user-called command intended for the last block
in a track
Why not extend the last block automatically?
First these are too many updates so performance goes down.
Second it confuses the user when he/she attempts to split
or append. Especially append.
"""
assert self is myParentCCTrack.blocks[-1]
plainScoreDuration = myParentCCTrack.score.duration()
durationWithoutLastBlock = myParentCCTrack.durationWithoutLastBlock()
#print ("score:", plainScoreDuration, "allOther", TempoBlock.tempoTrack.durationWithoutLastBlock())
if plainScoreDuration > 0 and plainScoreDuration > durationWithoutLastBlock:
self.duration = plainScoreDuration - durationWithoutLastBlock
class GraphTrackCC(object):
"""A track for midi Control Changes.
There is no cursor and no state. Just a sequence of blocks.
The actual CC value comes from the track."""
def __init__(self, cc, parentTrack):
firstBlock = GraphBlock(parentGraphTrack = self)
self.blocks = [firstBlock] #there is always at least one block.
self.cc = cc
self._secondInit(parentTrack = parentTrack)
def _secondInit(self, parentTrack):
"""see Score._secondInit"""
self.parentTrack = parentTrack
self.score = parentTrack.parentData
@classmethod
def instanceFromSerializedData(cls, serializedObject, parentObject):
"""see Score.instanceFromSerializedData"""
assert cls.__name__ == serializedObject["class"]
self = cls.__new__(cls)
self.cc = int(serializedObject["cc"])
self.blocks = [GraphBlock.instanceFromSerializedData(block, parentObject = self) for block in serializedObject["blocks"]]
self._secondInit(parentTrack = parentObject)
return self
def serialize(self):
result = {}
result["class"] = self.__class__.__name__
result["cc"] = self.cc
result["blocks"] = [block.serialize() for block in self.blocks]
return result
def durationWithoutLastBlock(self):
result = 0
for block in self.blocks[:-1]: #returns empty list when only one block in self.blocks. So no loop will happen and this function returns 0
result += block.duration
return result
def asListOfBlockIds(self):
"""Return an ordered list of block ids"""
result = []
for block in self.blocks:
result.append(id(block))
return result
def appendGraphBlock(self):
"""A simple method to add a new GraphBlock at the end of the
current track. Basically you can do the same with split and
resize, but this is much more easier."""
new = GraphBlock(parentGraphTrack = self)
return self.appendExistingGraphBlock(new)
def appendExistingGraphBlock(self, graphBlock):
self.blocks.append(graphBlock)
return graphBlock
def splitGraphBlock(self, graphBlock, positionInTicksRelativeToBlock):
"""The new block will be right of the original content. If the new block will be empty
or has no real start value the last prevailing value will be used
as the blocks start-point"""
#TODO: refactoring. This is bascially a copy of splitTempoBlock except the block is not an id here. And the name.
block = graphBlock
assert block.duration > positionInTicksRelativeToBlock
hasPointAtZero = False
toDelete = []
modelNewBlock = GraphBlock(parentGraphTrack = self) #will not be used directly, but instead content links will be created.
for pos, item in block.data.items():
#Determine if a ccPoint gets to move to the new block
if pos >= positionInTicksRelativeToBlock:
if pos == positionInTicksRelativeToBlock:
hasPointAtZero = True
modelNewBlock.data[pos - positionInTicksRelativeToBlock] = item
toDelete.append(pos)
#else: ccPoint stays in the old block
for pos in toDelete:
del block.data[pos]
#Since every block comes with a value at position 0 we need to check if this was already replaced or if we need to adjust it to the real tempo at this point in time.
if not hasPointAtZero:
realStartCCPoint = block.data[block.getMaxContentPosition()] #only the remaining items.
modelNewBlock.data[0] = realStartCCPoint.copy()
#Now the original block and all its content links have fewer items than before
#For every of the content-linked blocks in the tempo track we need to create a new block and insert it right next to it.
for bl in block.linkedContentBlocksInScore():
index = self.blocks.index(bl)
link = modelNewBlock.contentLink()
self.blocks.insert(index +1, link)
#duration is mutable. All content links change duration as well.
link.duration = block.duration - positionInTicksRelativeToBlock
block.duration = positionInTicksRelativeToBlock
del GraphBlock.allBlocks[id(modelNewBlock)] #Clean up the model block since it was never intended to go into the TempoTrack
return True
def mergeWithNextGraphBlock(self, graphBlock):
"""see structures block (the music block) for an explanation about merging content linked
blocks.
Hidden items (after the current duration value) of the original block
will be deleted. Hidden items of the follow-up block will be merged, but stay hidden.
"""
#TODO: refactoring. This is bascially a copy of splitTempoBlock except the block is not an id here. And the name.
block = graphBlock
if len(self.blocks) == 1:
#print ("only one block in the track")
return False
blockIndex = self.blocks.index(block)
if blockIndex+1 == len(self.blocks):
#print ("not for the last block")
return False
nextIndex = blockIndex + 1
nextBlock = self.blocks[nextIndex]
firstBlock_endingValue = block.data[block.getMaxContentPosition()].ccStart
nextBlock_startingValue = nextBlock.data[0].ccStart
startDurationToReturnForUndo = block.duration
if len(block.linkedContentBlocksInScore()) == 1 and len(nextBlock.linkedContentBlocksInScore()) == 1: #both blocks are standalone. no content-links. This also prevents that both blocks are content links of each other.
block.deleteHiddenItems()
if firstBlock_endingValue == nextBlock_startingValue: #remove redundancy
del nextBlock.data[0]
for pos, item in nextBlock.data.items():
assert not pos + block.duration in block.data
block.data[pos + block.duration] = item
block.duration += nextBlock.duration
self.deleteBlock(nextBlock)
return startDurationToReturnForUndo
elif len(block.linkedContentBlocksInScore()) == len(nextBlock<