Struct Project

pub struct Project { /* private fields */ }

Implementations

impl<'a> Project

pub fn new(context: ProjectContext) -> Self

New object from the project context.

It will never hold pseudo-context of CURRENT_PROJECT, but hold real pointer. So, for example, project, returned from Reaper::current_project will not always remain the project in the active project tab, if the tab changes.

Note

It is better to get all opened projects in once by Reaper::iter_projects.

pub fn from_name(name: impl Into<String>) -> ReaperResult<Self>

Get opened project with a given name, if any.

Note

This operation, probably, of O(n³) complexity in the worst case, do not use a lot.

pub fn context(&self) -> ProjectContext

Get [reaper_medium::ProjectContext] to use with rea-rs crates.

pub fn make_current_project(&self)

Activate project tab with the project.

pub fn is_current_project(&self) -> bool

If the project tab is active.

pub fn with_current_project( &self, f: impl FnMut() -> ReaperResult<()>, ) -> ReaperResult<()>

pub fn is_dirty(&self) -> bool

Whether project is dirty (i.e. needing save).

pub fn mark_dirty(&mut self)

Mark project dirty (i.e. needing save).

pub fn pause(&mut self)

Direct way to simulate pause button hit.

pub fn is_paused(&self) -> bool

pub fn play(&mut self)

Direct way to simulate play button hit.

pub fn is_playing(&self) -> bool

pub fn record(&mut self)

Hit record button.

Note

This is sugar on top of the cation invocation.

pub fn is_recording(&self) -> bool

pub fn stop(&mut self)

Direct way to simulate stop button hit.

pub fn is_stopped(&self) -> bool

pub fn length(&self) -> Duration

pub fn get_time_range(&'a self, kind: TimeRangeKind) -> TimeRange<'a>

pub fn get_loop_selection(&'a self) -> TimeRange<'a>

pub fn get_time_selection(&'a self) -> TimeRange<'a>

pub fn is_loop_enabled(&self) -> bool

pub fn set_loop_enabled(&mut self, should_loop: bool)

pub fn close(self)

Close the project.

pub fn time_signature_at_position( &self, position: Position, ) -> (TimeSignature, f64)

Get time signature and tempo (BPM) at given position.

pub fn add_marker( &mut self, position: Position, name: Option<impl Into<String>>, color: impl Into<Option<Color>>, desired_index: impl Into<Option<usize>>, ) -> ReaperResult<usize>

Create new marker and return its index.

Return ReaperError::Unexpected if reaper can’t add marker.

If it is possible, the index will be the same as desired, but if it is busy, new index will be returned.

If a marker with the same position and name exists, no new marker will be created, and existing index will be returned.

index is not an enum index, but user-index.

pub fn add_region( &mut self, start: Position, end: Position, name: Option<impl Into<String>>, color: impl Into<Option<Color>>, desired_index: impl Into<Option<usize>>, ) -> ReaperResult<usize>

Create new region and return its index.

Return ReaperError::Unexpected if reaper can’t add marker.

If it is possible, the index will be the same as desired, but if it is busy, new index will be returned.

If a marker with the same position and name exists, no new marker will be created, and existing index will be returned.

index is not an enum index, but user-index.

pub fn set_marker_or_region( &mut self, info: MarkerRegionInfo, ) -> ReaperResult<()>

Set marker or region from info.

pub fn delete_marker(&mut self, user_index: usize) -> ReaperResult<()>

pub fn delete_region(&mut self, user_index: usize) -> ReaperResult<()>

pub fn iter_markers_and_regions(&self) -> MarkerRegionIterator<'_>

Get iterator through all project markers and regions.

Since markers and regions are messed up in indexes and API, it’s better to work with them through iteration.

Example

let project = Project::new(ProjectContext::CurrentProject);
assert_eq!(
    project
    .iter_markers_and_regions()
    .find(|info| !info.is_region && info.user_index == 2)
    .unwrap()
    .position
    .as_duration()
    .as_secs_f64(),
4.0
);

pub fn n_tracks(&self) -> usize

pub fn n_selected_tracks(&self) -> usize

pub fn n_items(&self) -> usize

pub fn n_selected_items(&self) -> usize

pub fn n_tempo_markers(&self) -> usize

pub fn n_markers(&self) -> usize

pub fn n_regions(&self) -> usize

pub fn add_track( &mut self, index: impl Into<Option<usize>>, name: impl Into<String>, ) -> Track<'_, Mutable>

pub fn get_track(&self, index: usize) -> Option<Track<'_, Immutable>>

pub fn get_track_mut(&mut self, index: usize) -> Option<Track<'_, Mutable>>

pub fn get_selected_track(&self, index: usize) -> Option<Track<'_, Immutable>>

pub fn get_selected_track_mut( &mut self, index: usize, ) -> Option<Track<'_, Mutable>>

pub fn get_master_track(&self) -> Track<'_, Immutable>

pub fn get_master_track_mut(&mut self) -> Track<'_, Mutable>

pub fn iter_tracks(&self) -> TracksIterator<'_>

pub fn iter_tracks_mut( &mut self, f: impl FnMut(Track<'_, Mutable>) -> ReaperResult<()>, ) -> ReaperResult<()>

pub fn iter_selected_tracks(&self) -> SelectedTracksIterator<'_>

pub fn iter_selected_tracks_mut( &mut self, f: impl FnMut(Track<'_, Mutable>) -> ReaperResult<()>, ) -> ReaperResult<()>

pub fn iter_items(&'a self) -> ItemsIterator<'a>

pub fn iter_selected_items(&'a self) -> SelectedItemsIterator<'a>

pub fn get_item(&self, index: usize) -> Option<Item<'_, Immutable>>

pub fn get_item_mut(&mut self, index: usize) -> Option<Item<'_, Mutable>>

pub fn get_selected_item(&self, index: usize) -> Option<Item<'_, Immutable>>

pub fn get_selected_item_mut( &mut self, index: usize, ) -> Option<Item<'_, Mutable>>

pub fn glue_selected_items(&mut self, within_time_selection: bool)

Glue items (action shortcut).

pub fn any_track_solo(&self) -> bool

pub fn begin_undo_block(&mut self)

Verbose way to make undo.

Safety

Project::end_undo_block has to be called after.

pub fn end_undo_block(&mut self, name: impl Into<String>, flags: UndoFlags)

Verbose way to make undo: name is the name shown in undo list.

Safety

Project::begin_undo_block has to be called before.

pub fn with_undo_block( &mut self, undo_name: impl Into<String>, flags: UndoFlags, f: impl FnMut() -> ReaperResult<()>, ) -> ReaperResult<()>

Call function in undo block with given name.

Note

Probably, it’s better to use UndoFlags.all() by default.

pub fn undo(&mut self) -> Result<(), ReaperError>

Try to undo last action.

pub fn redo(&mut self) -> Result<(), ReaperError>

Try to redo last undone action.

pub fn next_buffer_position(&self) -> Position

Position of next audio block being processed.

Project::play_position

pub fn play_position(&self) -> Position

Latency-compensated actual-what-you-hear position.

Project::next_buffer_position

pub fn bypass_fx_on_all_tracks(&mut self, bypass: bool)

Bypass (true) or un-bypass (false) FX on all tracks.

pub fn next_redo(&self) -> Option<String>

Get the name of the next action in redo queue, if any.

pub fn next_undo(&self) -> Option<String>

Get the name of the next action in undo queue, if any.

pub fn get_cursor_position(&self) -> Position

Edit cursor position.

pub fn set_cursor_position( &mut self, position: Position, move_view: bool, seek_play: bool, )

Set edit cursor position.

pub fn disarm_rec_on_all_tracks(&mut self)

Disarm record on all tracks.

pub fn focused_fx(&self) -> Option<FocusedFxResult>

Check if there is any FX window in focus.

Returns enough data for getting Fx by yourself, as it will be easier, than conquer borrow checker or force you to pass closure inside.

FocusedFxResult

pub fn set_string_param_size(&mut self, size: usize)

Overwrite default size of string buffer, used to set and get string values:

Project::get_info_string Project::set_info_string

Example

use rea_rs::{Reaper, Project};
let mut pr = Reaper::get().current_project();
let directory = match pr.get_render_directory(){
    Err(_) => {
                pr.set_string_param_size(2048);
                pr.get_render_directory()
                    .expect("another reason of error")
            },
    Ok(dir) => dir,
};

pub fn name(&self) -> String

pub fn get_title(&self) -> ReaperResult<String>

title field from Project Settings/Notes dialog

pub fn set_title(&mut self, title: impl Into<String>) -> ReaperResult<()>

title field from Project Settings/Notes dialog

pub fn get_author(&self) -> ReaperResult<String>

author field from Project Settings/Notes dialog

pub fn set_author(&mut self, author: impl Into<String>) -> ReaperResult<()>

author field from Project Settings/Notes dialog

pub fn get_marker_guid(&self, marker_index: usize) -> ReaperResult<String>

pub fn get_track_group_name(&self, group_index: usize) -> ReaperResult<String>

pub fn set_track_group_name( &mut self, group_index: usize, track_group_name: impl Into<String>, ) -> ReaperResult<()>

pub fn get_record_path(&self, secondary_path: bool) -> ReaperResult<PathBuf>

pub fn get_path(&self) -> ReaperResult<PathBuf>

Project path.

pub fn set_record_path( &mut self, secondary_path: bool, directory: impl Into<PathBuf>, ) -> ReaperResult<()>

pub fn get_render_directory(&self) -> ReaperResult<PathBuf>

pub fn set_render_directory( &mut self, directory: impl Into<PathBuf>, ) -> ReaperResult<()>

pub fn get_render_file(&self) -> ReaperResult<String>

render file name (may contain wildcards)

pub fn set_render_file(&mut self, file: impl Into<String>) -> ReaperResult<()>

render file name (may contain wildcards)

pub fn get_render_format(&self, secondary_format: bool) -> ReaperResult<String>

base64-encoded sink configuration (see project files, etc).

Set secondary_format to true, if you want the secondary render section format.

pub fn set_render_format( &mut self, format: impl Into<String>, secondary_format: bool, ) -> ReaperResult<()>

base64-encoded secondary sink configuration.

Set secondary_format to true, if you want the secondary render section format.

Callers can also pass a simple 4-byte string (non-base64-encoded), e.g. “evaw” or “l3pm”, to use default settings for that sink type.

Typical formats

“wave” “aiff” “caff” “iso “ “ddp “ “flac” “mp3l” “oggv” “OggS”

pub fn get_render_targets(&self) -> ReaperResult<Vec<String>>

Filenames, that will be rendered.

pub fn get_play_rate(&self, position: impl Into<Position>) -> PlayRate

Will return PlayRate::from(1.0) in normal conditions.

pub fn save(&mut self, force_save_as: bool)

pub fn select_all_items(&mut self, should_select: bool)

pub fn select_all_tracks(&mut self, should_select: bool)

pub fn solo_all_tracks(&mut self, solo: bool)

pub fn mute_all_tracks(&mut self, mute: bool)

pub fn clear_all_rec_armed_tracks(&mut self)

pub fn get_render_bounds_mode(&self) -> BoundsMode

pub fn set_render_bounds_mode(&mut self, mode: BoundsMode)

pub fn get_render_settings(&self) -> RenderSettings

pub fn set_render_settings(&mut self, settings: RenderSettings)

pub fn get_render_channels_amount(&self) -> u32

pub fn set_render_channels_amount(&mut self, channels_amount: u32)

pub fn get_srate(&self) -> Option<u32>

If None — then sample rate from Reaper settings used.

pub fn set_srate(&mut self, srate: impl Into<Option<u32>>)

If None — then sample rate from Reaper settings used.

pub fn get_render_srate(&self) -> Option<u32>

If None — then project sample rate used.

pub fn set_render_srate(&mut self, srate: impl Into<Option<u32>>)

If None — then project sample rate used.

pub fn get_render_bounds(&self) -> (Position, Position)

Get in tuple (start, end)

Valid only when Project::get_render_bounds_mode is BoundsMode::Custom

pub fn set_render_bounds( &mut self, start: impl Into<Position>, end: impl Into<Position>, )

Valid only when Project::get_render_bounds_mode is BoundsMode::Custom

pub fn get_render_tail(&self) -> RenderTail

pub fn set_render_tail(&mut self, render_tail: RenderTail)

Trait Implementations

impl Debug for Project

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HasExtState for Project

fn set_ext_value(&self, section: &CStr, key: &CStr, value: *mut i8)

fn get_ext_value( &self, section: &CStr, key: &CStr, buf_size: usize, ) -> Option<CString>

fn delete_ext_value(&self, section: &CStr, key: &CStr)

impl PartialEq for Project

fn eq(&self, other: &Project) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> WithReaperPtr for Project

type Ptr = NonNull<ReaProject>

fn get_pointer(&self) -> Self::Ptr

Get underlying ReaperPointer.

fn get(&self) -> Self::Ptr

Get underlying ReaperPointer with validity check.

fn make_unchecked(&mut self)

Turn validity checks off.

fn make_checked(&mut self)

Turn validity checks on.

fn should_check(&self) -> bool

State of validity checks.

fn require_valid(&self) -> ReaperResult<()>

Return ReaperError::NullPtr if check failed.

fn require_valid_2(&self, project: &Project) -> ReaperResult<()>

Return ReaperError::NullPtr if check failed.

fn with_valid_ptr( &mut self, f: impl FnMut(&mut Self) -> ReaperResult<()>, ) -> ReaperResult<()>

Perform function with only one validity check.

impl StructuralPartialEq for Project