async def setup(self) -> None:
await super().setup()
self.__cmdline = self.get_cmd_line()
logger.info("Starting encoder process: %s", ' '.join(self.__cmdline))
self.__stderr = []
transport, protocol = await self.event_loop.subprocess_exec(
functools.partial(EncoderProtocol,
data_handler=self.data_handler,
stderr_handler=self.__stderr.append,
failure_handler=self.__fail,
event_loop=self.event_loop),
*self.__cmdline,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE)
self.__transport = down_cast(asyncio.SubprocessTransport, transport)
self.__protocol = down_cast(EncoderProtocol, protocol)
self.__stdin = asyncio.StreamWriter(
transport=self.__transport.get_pipe_transport(0),
protocol=self.__protocol,
reader=None,
loop=self.event_loop)
def create_empty_measure(
self, ref: Optional[base_track.Measure]) -> ScoreMeasure:
measure = down_cast(ScoreMeasure, super().create_empty_measure(ref))
if ref is not None:
ref = down_cast(ScoreMeasure, ref)
measure.key_signature = ref.key_signature
measure.clef = ref.clef
return measure
def _add_measure_listeners(self,
mref: base_track.MeasureReference) -> None:
measure = down_cast(BeatMeasure, mref.measure)
self._listeners['measure:%s:beats' %
mref.id] = measure.content_changed.add(
lambda _=None: self.__measure_beats_changed(mref)
) # type: ignore[misc]
def remove_connections(self) -> None:
node = down_cast(BaseNode, self.parent)
if node is not None:
for conn in node.connections:
if (conn.source_node is node and conn.source_port == self.name
or conn.dest_node is node and conn.dest_port == self.name):
self.project.remove_node_connection(conn)
def _create_events(
self, time: audioproc.MusicalTime, measure: base_track.Measure
) -> Iterator[base_track.PianoRollInterval]:
measure = down_cast(BeatMeasure, measure)
for beat in measure.beats:
beat_time = time + beat.time
event = base_track.PianoRollInterval(
beat_time, beat_time + audioproc.MusicalDuration(1, 4),
self._node.pitch, 127)
yield event
def parent(self, index: QtCore.QModelIndex) -> QtCore.QModelIndex: # type: ignore[override]
if not index.isValid():
return QtCore.QModelIndex()
item = down_cast(ModelItem, index.internalPointer())
parent = item.parent
if parent is self.__root:
return QtCore.QModelIndex()
return self.createIndex(parent.index, 0, parent)
def _create_events(
self, time: audioproc.MusicalTime, measure: base_track.Measure
) -> Iterator[base_track.PianoRollInterval]:
measure = down_cast(ScoreMeasure, measure)
for note in measure.notes:
if not note.is_rest:
for pitch in note.pitches:
pitch = pitch.transposed(
octaves=self._node.transpose_octaves)
event = base_track.PianoRollInterval(
time, time + note.duration, pitch, 127)
yield event
time += note.duration
async def setup_testcase(self):
with self.project.apply_mutations('test'):
self.node = self.project.create_node('builtin://custom-csound')
with self.project.apply_mutations('test'):
self.node.create_port(0, 'port1')
self.node.create_port(1, 'port2')
self.node.create_port(2, 'port3')
self.port_list_editor = node_ui.PortListEditor(
node=self.node, context=self.context)
self.table = self.port_list_editor.findChild(
QtWidgets.QTableView, "object_table", Qt.FindChildrenRecursively)
self.model = down_cast(object_list_editor.ObjectListModel, self.table.model())
self.delegate = self.table.itemDelegate()
def pipe_data_received(self, fd: int, data: Union[bytes, Text]) -> None:
data = down_cast(bytes, data)
if fd == 1:
logger.debug("Writing %d encoded bytes", len(data))
self.__data_handler(data)
else:
assert fd == 2
self.__stderr_buf.extend(data)
while True:
eol = self.__stderr_buf.find(b'\n')
if eol < 0:
break
line = self.__stderr_buf[:eol].decode('utf-8')
del self.__stderr_buf[:eol + 1]
self.__stderr_handler(line)
def paste_segments(
self, data: clipboard_pb2.PianoRollSegments,
time: audioproc.MusicalTime) -> List[PianoRollSegmentRef]:
segment_map = {} # type: Dict[int, PianoRollSegment]
for serialized_segment in data.segments:
segment = down_cast(PianoRollSegment,
self._pool.clone_tree(serialized_segment))
self.segment_heap.append(segment)
segment_map[serialized_segment.root] = segment
segment_refs = [] # type: List[PianoRollSegmentRef]
for serialized_segment_ref in data.segment_refs:
ref_time = audioproc.MusicalTime.from_proto(
serialized_segment_ref.time)
ref = self._pool.create(
PianoRollSegmentRef,
time=time + (ref_time - audioproc.MusicalTime(0, 1)),
segment=segment_map[serialized_segment_ref.segment])
self.segments.append(ref)
segment_refs.append(ref)
return segment_refs
def project(self) -> music.Project:
return down_cast(music.Project,
self.__project_connection.client.project)
def midi_cc_to_cv(self) -> 'MidiCCtoCV':
return down_cast(MidiCCtoCV, self.parent)
def track_editor(self) -> 'BeatTrackEditor':
return down_cast(BeatTrackEditor, super().track_editor)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
self.__transport = down_cast(asyncio.SubprocessTransport, transport)
def measure(self) -> model.ScoreMeasure:
return down_cast(model.ScoreMeasure, super().measure)
def track_editor(self) -> 'ScoreTrackEditor':
return down_cast(ScoreTrackEditor, super().track_editor)
def track(self) -> model.ControlTrack:
return down_cast(model.ControlTrack, super().track)
def prev_sibling(self) -> 'MeasureReference':
return down_cast(MeasureReference, super().prev_sibling)
def track(self) -> 'ScoreTrack':
return down_cast(ScoreTrack, super().track)
def next_sibling(self) -> 'MeasureReference':
return down_cast(MeasureReference, super().next_sibling)
def track(self) -> music.MeasuredTrack:
return down_cast(music.MeasuredTrack, self.__track_editor.track)
def item(self, index: QtCore.QModelIndex = QtCore.QModelIndex()) -> Item:
if not index.isValid():
return self.__root
else:
return down_cast(Item, index.internalPointer())
def track(self) -> music.MeasuredTrack:
return down_cast(music.MeasuredTrack, super().track)
def __currentToolChanged(self, tool: tools.ToolType) -> None:
self.setDelegatedCopyable(
down_cast(MeasuredTrackToolBase, self.currentTool()))
def enterEvent(self, evt: QtCore.QEvent) -> None:
evt = down_cast(QtGui.QEnterEvent, evt)
self.setHoverMeasureEditor(self.measureEditorAt(evt.pos()), evt)
def track(self) -> model.ScoreTrack:
return down_cast(model.ScoreTrack, super().track)
def node(self) -> 'CustomCSound':
return down_cast(CustomCSound, self.parent)
def paintBackground(self, painter: QtGui.QPainter) -> None:
ymid = self.height() // 2
painter.setPen(Qt.black)
painter.setBrush(Qt.black)
for l in range(-2, 3):
painter.drawLine(0, ymid + 20 * l, self.width() - 1, ymid + 20 * l)
if self.is_first:
painter.fillRect(0, ymid - 40, 2, 20 * 4, Qt.black)
painter.drawLine(self.width() - 1, ymid - 40,
self.width() - 1, ymid + 40)
if not self.measure_reference.is_first:
prev_sibling = down_cast(
model.ScoreMeasure,
self.measure_reference.prev_sibling.measure)
else:
prev_sibling = None
base_stave_line = self.measure.clef.center_pitch.stave_line
base_octave = self.measure.clef.base_octave
x = 0
paint_clef = prev_sibling is None or self.measure.clef != prev_sibling.clef
if paint_clef and self.width() - x > 200:
svg_symbol.paintSymbol(
painter, 'clef-%s' % self.measure.clef.symbol,
QtCore.QPoint(
x + 30, ymid - 10 *
(self.measure.clef.base_pitch.stave_line - base_stave_line)
))
x += 60
acc_map = {
'C#': 'C%d' % (base_octave + 1),
'D#': 'D%d' % (base_octave + 1),
'E#': 'E%d' % (base_octave + 1),
'F#': 'F%d' % (base_octave + 1),
'G#': 'G%d' % (base_octave + 1),
'A#': 'A%d' % base_octave,
'B#': 'B%d' % base_octave,
'Cb': 'C%d' % (base_octave + 1),
'Db': 'D%d' % (base_octave + 1),
'Eb': 'E%d' % (base_octave + 1),
'Fb': 'F%d' % base_octave,
'Gb': 'G%d' % base_octave,
'Ab': 'A%d' % base_octave,
'Bb': 'B%d' % base_octave,
}
paint_key_signature = (
prev_sibling is None
or self.measure.key_signature != prev_sibling.key_signature)
if paint_key_signature and self.width() - x > 200:
for acc in self.measure.key_signature.accidentals:
value = acc_map[acc]
stave_line = value_types.Pitch(
value).stave_line - base_stave_line
svg_symbol.paintSymbol(
painter, self._accidental_map[acc[1:]],
QtCore.QPoint(x + 10, ymid - 10 * stave_line))
x += 10
if self.measure.key_signature.accidentals:
x += 10
paint_time_signature = (
prev_sibling is None
or self.measure.time_signature != prev_sibling.time_signature)
if paint_time_signature and self.width() - x > 200:
font = QtGui.QFont('FreeSerif', 30, QtGui.QFont.Black)
font.setStretch(120)
painter.setFont(font)
painter.drawText(x, ymid - 5,
'%d' % self.measure.time_signature.upper)
painter.drawText(x, ymid + 32,
'%d' % self.measure.time_signature.lower)
x += 40
if self.width() - x > 100:
self._note_area = (x + 20, self.width() - x - 20)
else:
self._note_area = (0, self.width())
def sequencer(self) -> 'StepSequencer':
return down_cast(StepSequencer, self.parent)
