ProjectSound class¶

@set_as_current
def remove(self) -> None:
    """Remove the sound from the project."""
    george.tv_sound_project_remove(self.track_index)
    self.mark_removed()

def reload(self) -> None:
    """Reload the sound from file."""
    george.tv_sound_project_reload(self.project.id, self.track_index)

def make_current(self) -> None:
    """Makes the sound project current."""
    self.project.make_current()

def refresh(self) -> None:
    """Refreshes the sound data."""
    super().refresh()
    if not self.refresh_on_call and self._data:
        return
    self._data = self._info(self.parent.id, self.track_index)

def mark_removed(self) -> None:
    """Marks the object as removed and is therefor not usable."""
    self._is_removed = True

@classmethod
def iter_sounds_data(cls, parent_id: str | int) -> Iterator[george.TVPSound]:
    """Returns an iterator over the sound's data."""
    return utils.position_generator(lambda track_index: cls._info(parent_id, track_index))

@classmethod
def new(cls: type[Self], sound_path: Path | str, parent: P) -> Self:
    """Create a new sound from the sound path."""
    parent.make_current()
    cls._new(Path(sound_path))
    last_index = len(list(cls.iter_sounds_data(parent.id))) - 1
    return cls(last_index, parent)

@offset.setter
def offset(self, value: float) -> None:
    self._adjust(offset=value)

@volume.setter
@set_as_current
def volume(self, value: float) -> None:
    self._adjust(volume=value)

@is_muted.setter
@set_as_current
def is_muted(self, value: bool) -> None:
    self._adjust(mute=value)

@fade_in_start.setter
@set_as_current
def fade_in_start(self, value: float) -> None:
    self._adjust(fade_in_start=value)

@fade_in_stop.setter
@set_as_current
def fade_in_stop(self, value: float) -> None:
    self._adjust(fade_in_stop=value)

@fade_out_start.setter
@set_as_current
def fade_out_start(self, value: float) -> None:
    self._adjust(fade_out_start=value)

@fade_out_stop.setter
@set_as_current
def fade_out_stop(self, value: float) -> None:
    self._adjust(fade_out_stop=value)

@refreshed_property
def path(self) -> Path:
    """The sound source file path."""
    return self._data.path

@refreshed_property
def sound_in(self) -> float:
    """The start time of the sound."""
    return self._data.sound_in

@refreshed_property
def sound_out(self) -> float:
    """The end time of the sound."""
    return self._data.sound_out

@color_index.setter
@set_as_current
def color_index(self, value: int) -> None:
    self._adjust(color_index=value)