def mute(self): """Mute track (do nothing if track is already muted).""" code = """ if not track.is_muted: track.toggle_mute() """ Program(code).run(track=self)
def add_item(self, start=0, end=None, length=0): """ Create new item on track and return it. Parameters ---------- start : float, optional New item start in seconds (default=0). end : float, optional New item end in seconds (default None). If None, `length` is used instead. length : float, optional New item length in seconds (default 0). Returns ------- item : Item New item on track. """ if end is None: end = start + length code = """ item_id = RPR.AddMediaItemToTrack(track_id) item = reapy.Item(item_id) item.position = start item.length = end - start """ item = Program(code, "item").run( track_id=self.id, start=start, end=end )[0] return item
def add_track(self, index=0, name=""): """ Add track at a specified index. Parameters ---------- index : int Index at which to insert track. name : str, optional Name of created track. Returns ------- track : Track New track. """ code = """ current_project = reapy.Project() project.make_current_project() n_tracks = project.n_tracks index = max(-n_tracks, min(index, n_tracks)) if index < 0: index = index % n_tracks RPR.InsertTrackAtIndex(index, True) current_project.make_current_project() track = reapy.Track(RPR.GetTrack(project.id, index)) track.name = name """ track, = Program(code, "track").run(project=self, index=index, name=name) return track
def get_value(self, time, raw=False): """ Return envelope value at a given time. Parameters ---------- time : float Time in seconds. raw : bool, optional Whether to return raw value or its human-readable version, which is the one that is printed in REAPER GUI (default=False). Returns ------- value : float or str Envelope value. Examples -------- >>> envelope = track.envelopes["Pan"] >>> envelope.get_value(10, raw=True) -0.5145481809245827 >>> envelope.get_value(10) # human-readable '51%R' """ code = """ value = RPR.Envelope_Evaluate(env_id, time, 0, 0, 0, 0, 0, 0)[5] if not raw: value = RPR.Envelope_FormatValue(env_id, value, "", 2048)[2] """ value = Program(code, "value").run(env_id=self.id, time=time, raw=raw)[0] return value
def unmute(self): """Unmute track (do nothing if track is not muted).""" code = """ if track.is_muted: track.toggle_mute() """ Program(code).run(track=self)
def focused_fx(self): """ FX that has focus if any, else None. :type: FX or NoneType """ code = """ def get_focused_fx(): if not project.is_current_project: return res = RPR.GetFocusedFX(0, 0, 0) if not res[0]: return if res[1] == 0: track = project.master_track else: track = project.tracks[res[1] - 1] if res[0] == 1: # Track FX return track.fxs[res[3]] # Take FX item = track.items[res[2]] take = item.takes[res[3] // 2**16] return take.fxs[res[3] % 2**16] fx = get_focused_fx() """ fx, = Program(code, "fx").run(project=self) return fx
def infos(self): """ Return infos about CC. Keys are {"selected", "muted", "position", "channel", "channel_message", "messages"}. :type: dict """ code = """ res = list(RPR.MIDI_GetCC( take.id, index, 0, 0, 0, 0, 0, 0, 0 ))[3:] res[0] = bool(res[0]) res[1] = bool(res[1]) res[2] = take.ppq_to_time(res[2]) res[-2] = res[-2], res[-1] res.pop() keys = ( "selected", "muted", "position", "channel_message", "channel", "messages" ) infos = {k: r for k, r in zip(keys, res)} """ infos, = Program(code, "infos").run(take=self.parent, index=self.index) return infos
def last_touched_fx(self): """ Last touched FX and corresponding parameter index. :type: FX, int or NoneType, NoneType Notes ----- Only Track FX are detected by this property. If last touched FX is a Take FX, this property is ``(None, None)``. Examples -------- >>> fx, index = project.last_touched_fx >>> fx.name 'VSTi: ReaSamplOmatic5000 (Cockos)' >>> fx.params[index].name "Volume" """ code = """ if not project.is_current_project: fx, index = None, None else: res = RPR.GetLastTouchedFX(0, 0, 0) if not res[0]: fx, index = None, None else: if res[1]: track = project.tracks[res[1] - 1] else: track = project.master_track fx, index = track.fxs[res[2]], res[3] """ return tuple(Program(code, "fx", "index").run(project=self))
def __iter__(self): code = """ elements = [ro_list[i] for i in range(len(ro_list))] """ elements, = Program(code, "elements").run(ro_list=self) for element in elements: yield element
def infos(self): """ Return infos about note. Keys are {"selected", "muted", "start", "end", "channel", "pitch", "velocity"}. :type: dict """ code = """ res = list(RPR.MIDI_GetNote( take.id, index, 0, 0, 0, 0, 0, 0, 0 ))[3:] res[0] = bool(res[0]) res[1] = bool(res[1]) res[2] = take.ppq_to_time(res[2]) res[3] = take.ppq_to_time(res[3]) keys = ( "selected", "muted", "start", "end", "channel", "pitch", "velocity" ) infos = {k: r for k, r in zip(keys, res)} """ infos, = Program(code, "infos").run(take=self.parent, index=self.index) return infos
def unsolo(self): """Unsolo track (do nothing if track is not solo).""" code = """ if track.is_solo: track.toggle_solo() """ Program(code).run(track=self)
def solo(self): """Solo track (do nothing if track is already solo).""" code = """ if not track.is_solo: track.toggle_solo() """ Program(code).run(track=self)
def flip_phase(self): """ Toggle whether phase is flipped. """ code = """ send.is_phase_flipped = not send.is_phase_flipped """ Program(code).run(send=self)
def selected_tracks(self, tracks): tracks = list(tracks) code = """ project.unselect_all_tracks() for track in tracks: track.select() """ Program(code).run(project=self, tracks=tracks)
def sends(self): code = """ sends = [ reapy.Send(track, i, type="send") for i in range(track.n_sends) ] """ sends = Program(code, "sends").run(track=self)[0] return sends
def __iter__(self): code = """ values = [param_list.functions["GetParam"]( param_list.parent_id, param_list.fx_index, i, 0, 0 )[0] for i in range(len(param_list))] """ values, = Program(code, "values").run(param_list=self) for i, value in enumerate(values): yield FXParam(value, self, i, self.functions)
def toggle_solo(self): """Toggle solo on track.""" code = """ project = track.project selected_tracks = project.selected_tracks track.make_only_selected_track() project.perform_action(7) project.selected_tracks = selected_tracks """ Program(code).run(track=self)
def toggle_mute(self): """Toggle mute on track.""" code = """ project = track.project selected_tracks = project.selected_tracks track.make_only_selected_track() project.perform_action(40280) project.selected_tracks = selected_tracks """ Program(code).run(track=self)
def _get_param_index(self, name): code = """ names = [param_list[i].name for i in range(len(param_list))] index = names.index(name) """ try: index = Program(code, "index").run(name=name, param_list=self)[0] return index except DistError: raise IndexError("{} has no param named {}".format( self.parent_fx, name))
def disarm_rec_on_all_tracks(self): """ Disarm record on all tracks. """ code = """ current_project = reapy.Project() project.make_current_project() RPR.ClearAllRecArmed() current_project.make_current_project() """ Program(code).run(project=self)
def is_active(self): """ Whether take is active. :type: bool """ code = """ from reapy.core.item.take import Take take = Take(take_id) is_active = take == take.item.active_take """ return Program(code, "is_active").run(take_id=self.id)[0]
def items(self): """ List of items in project. :type: list of Item """ code = """ n_items = project.n_items item_ids = [RPR.GetMediaItem(project.id, i) for i in range(n_items)] """ item_ids, = Program(code, "item_ids").run(project=self) return list(map(reapy.Item, item_ids))
def _get_enum_index(self): """ Return marker index as needed by RPR.EnumProjectMarkers2. """ code = """ index = [ i for i, m in enumerate(project.markers) if m.index == marker.index ][0] """ index = Program(code, "index").run(marker=self, project=reapy.Project(self.project_id))[0] return index
def project(self): """ Track parent project. :type: Project """ if self._project is None: code = """ for project in reapy.get_projects(): if track.id in [t.id for t in project.tracks]: break """ self._project, = Program(code, "project").run(track=self) return self._project
def time_selection(self, selection): """ Set time selection bounds. Parameters ---------- selection : (float, float) Start and end of new time selection in seconds. """ code = """ project.time_selection.start = selection[0] project.time_selection.end = selection[1] """ Program(code).run(project=self, selection=selection)
def _get_project(self): """ Return parent project of track. Should only be used internally; one should directly access Track.project instead of calling this method. """ code = """ for project in reapy.get_projects(): if track.id in [t.id for t in project.tracks]: break """ project, = Program(code, "project").run(track=self) return project
def start(self): """ Region start. :type: float """ code = """ index = region._get_enum_index() start = RPR.EnumProjectMarkers2( region.project_id, index, 0, 0, 0, 0, 0 )[4] """ start = Program(code, "start").run(region=self)[0] return start
def _get_enum_index(self): """ Return region index as needed by RPR.EnumProjectMarkers2. """ code = """ index = [ i for i, r in enumerate(project.regions) if r.index == region.index ][0] """ index = Program(code, "index").run(region=self, project=reapy.Project(self.project_id))[0] return index
def unsolo_all_tracks(self): """ Unsolo all tracks in project. See also -------- Project.solo_all_tracks """ code = """ current_project = reapy.Project() project.make_current_project() RPR.SoloAllTracks(0) current_project.make_current_project() """ Program(code).run(project=self)
def selected_tracks(self): """ List of selected tracks (excluding master). :type: list of Track """ code = """ track_ids = [ RPR.GetSelectedTrack(project_id, i) for i in range(reapy.Project(project_id).n_selected_tracks) ] """ track_ids = Program(code, "track_ids").run(project_id=self.id)[0] tracks = list(map(reapy.Track, track_ids)) return tracks