Struct reaper_low::Reaper

pub struct Reaper { /* private fields */ }

This is the low-level API access point to all REAPER functions.

In order to use it, you first must obtain an instance of this struct by invoking load().

Default::default() will give you an instance which panics on each function call. It’s intended to be used for example code only.

Panics

Please note that it’s possible that functions are not available. This can be the case if the user runs your plug-in in an older version of REAPER which doesn’t have that function yet. The availability of a function can be checked by inspecting the respective function pointer option accessible via the pointers() method. The actual methods in this structs are just convenience methods which unwrap the function pointers and panic if they are not available.

Implementations

impl Reaper

pub fn load(plugin_context: PluginContext) -> Reaper

Loads all available REAPER functions from the given plug-in context.

Returns a low-level Reaper instance which allows you to call these functions.

pub unsafe fn __mergesort(
    &self,
    base: *mut c_void,
    nmemb: usize,
    size: usize,
    cmpfunc: Option<unsafe extern "C" fn(arg1: *const c_void, arg2: *const c_void) -> c_int>,
    tmpspace: *mut c_void
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn AddCustomizableMenu(
    &self,
    menuidstr: *const c_char,
    menuname: *const c_char,
    kbdsecname: *const c_char,
    addtomainmenu: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn AddExtensionsMainMenu(&self) -> bool

pub unsafe fn AddMediaItemToTrack(&self, tr: *mut MediaTrack) -> *mut MediaItem

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn AddProjectMarker(
    &self,
    proj: *mut ReaProject,
    isrgn: bool,
    pos: f64,
    rgnend: f64,
    name: *const c_char,
    wantidx: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn AddProjectMarker2(
    &self,
    proj: *mut ReaProject,
    isrgn: bool,
    pos: f64,
    rgnend: f64,
    name: *const c_char,
    wantidx: c_int,
    color: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn AddRemoveReaScript(
    &self,
    add: bool,
    sectionID: c_int,
    scriptfn: *const c_char,
    commit: bool
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn AddTakeToMediaItem(
    &self,
    item: *mut MediaItem
) -> *mut MediaItem_Take

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn AddTempoTimeSigMarker(
    &self,
    proj: *mut ReaProject,
    timepos: f64,
    bpm: f64,
    timesig_num: c_int,
    timesig_denom: c_int,
    lineartempochange: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn adjustZoom(&self, amt: f64, forceset: c_int, doupd: bool, centermode: c_int)

pub unsafe fn AnyTrackSolo(&self, proj: *mut ReaProject) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn APIExists(&self, function_name: *const c_char) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn APITest(&self)

pub unsafe fn ApplyNudge(
    &self,
    project: *mut ReaProject,
    nudgeflag: c_int,
    nudgewhat: c_int,
    nudgeunits: c_int,
    value: f64,
    reverse: bool,
    copies: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ArmCommand(&self, cmd: c_int, sectionname: *const c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn Audio_Init(&self)

pub fn Audio_IsPreBuffer(&self) -> c_int

pub fn Audio_IsRunning(&self) -> c_int

pub fn Audio_Quit(&self)

pub unsafe fn Audio_RegHardwareHook(
    &self,
    isAdd: bool,
    reg: *mut audio_hook_register_t
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn AudioAccessorStateChanged(
    &self,
    accessor: *mut AudioAccessor
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn AudioAccessorUpdate(&self, accessor: *mut AudioAccessor)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn AudioAccessorValidateState(
    &self,
    accessor: *mut AudioAccessor
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn BypassFxAllTracks(&self, bypass: c_int)

pub unsafe fn CalcMediaSrcLoudness(&self, mediasource: *mut PCM_source) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CalculateNormalization(
    &self,
    source: *mut PCM_source,
    normalizeTo: c_int,
    normalizeTarget: f64,
    normalizeStart: f64,
    normalizeEnd: f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CalculatePeaks(
    &self,
    srcBlock: *mut PCM_source_transfer_t,
    pksBlock: *mut PCM_source_peaktransfer_t
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CalculatePeaksFloatSrcPtr(
    &self,
    srcBlock: *mut PCM_source_transfer_t,
    pksBlock: *mut PCM_source_peaktransfer_t
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn ClearAllRecArmed(&self)

pub fn ClearConsole(&self)

pub fn ClearPeakCache(&self)

pub unsafe fn ColorFromNative(
    &self,
    col: c_int,
    rOut: *mut c_int,
    gOut: *mut c_int,
    bOut: *mut c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn ColorToNative(&self, r: c_int, g: c_int, b: c_int) -> c_int

pub unsafe fn CountActionShortcuts(
    &self,
    section: *mut KbdSectionInfo,
    cmdID: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountAutomationItems(&self, env: *mut TrackEnvelope) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountEnvelopePoints(&self, envelope: *mut TrackEnvelope) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountEnvelopePointsEx(
    &self,
    envelope: *mut TrackEnvelope,
    autoitem_idx: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountMediaItems(&self, proj: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountProjectMarkers(
    &self,
    proj: *mut ReaProject,
    num_markersOut: *mut c_int,
    num_regionsOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountSelectedMediaItems(&self, proj: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountSelectedTracks(&self, proj: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountSelectedTracks2(
    &self,
    proj: *mut ReaProject,
    wantmaster: bool
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountTakeEnvelopes(&self, take: *mut MediaItem_Take) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountTakes(&self, item: *mut MediaItem) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountTCPFXParms(
    &self,
    project: *mut ReaProject,
    track: *mut MediaTrack
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountTempoTimeSigMarkers(&self, proj: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountTrackEnvelopes(&self, track: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountTrackMediaItems(&self, track: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CountTracks(&self, projOptional: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CreateLocalOscHandler(
    &self,
    obj: *mut c_void,
    callback: *mut c_void
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub fn CreateMIDIInput(&self, dev: c_int) -> *mut midi_Input

pub unsafe fn CreateMIDIOutput(
    &self,
    dev: c_int,
    streamMode: bool,
    msoffset100: *mut c_int
) -> *mut midi_Output

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CreateNewMIDIItemInProj(
    &self,
    track: *mut MediaTrack,
    starttime: f64,
    endtime: f64,
    qnInOptional: *const bool
) -> *mut MediaItem

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CreateTakeAudioAccessor(
    &self,
    take: *mut MediaItem_Take
) -> *mut AudioAccessor

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CreateTrackAudioAccessor(
    &self,
    track: *mut MediaTrack
) -> *mut AudioAccessor

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CreateTrackSend(
    &self,
    tr: *mut MediaTrack,
    desttrInOptional: *mut MediaTrack
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn CSurf_FlushUndo(&self, force: bool)

pub unsafe fn CSurf_GetTouchState(
    &self,
    trackid: *mut MediaTrack,
    isPan: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn CSurf_GoEnd(&self)

pub fn CSurf_GoStart(&self)

pub fn CSurf_NumTracks(&self, mcpView: bool) -> c_int

pub fn CSurf_OnArrow(&self, whichdir: c_int, wantzoom: bool)

pub fn CSurf_OnFwd(&self, seekplay: c_int)

pub unsafe fn CSurf_OnFXChange(&self, trackid: *mut MediaTrack, en: c_int) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnInputMonitorChange(
    &self,
    trackid: *mut MediaTrack,
    monitor: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnInputMonitorChangeEx(
    &self,
    trackid: *mut MediaTrack,
    monitor: c_int,
    allowgang: bool
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnMuteChange(
    &self,
    trackid: *mut MediaTrack,
    mute: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnMuteChangeEx(
    &self,
    trackid: *mut MediaTrack,
    mute: c_int,
    allowgang: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnOscControlMessage(
    &self,
    msg: *const c_char,
    arg: *const f32
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnPanChange(
    &self,
    trackid: *mut MediaTrack,
    pan: f64,
    relative: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnPanChangeEx(
    &self,
    trackid: *mut MediaTrack,
    pan: f64,
    relative: bool,
    allowGang: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub fn CSurf_OnPause(&self)

pub fn CSurf_OnPlay(&self)

pub fn CSurf_OnPlayRateChange(&self, playrate: f64)

pub unsafe fn CSurf_OnRecArmChange(
    &self,
    trackid: *mut MediaTrack,
    recarm: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnRecArmChangeEx(
    &self,
    trackid: *mut MediaTrack,
    recarm: c_int,
    allowgang: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn CSurf_OnRecord(&self)

pub unsafe fn CSurf_OnRecvPanChange(
    &self,
    trackid: *mut MediaTrack,
    recv_index: c_int,
    pan: f64,
    relative: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnRecvVolumeChange(
    &self,
    trackid: *mut MediaTrack,
    recv_index: c_int,
    volume: f64,
    relative: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub fn CSurf_OnRew(&self, seekplay: c_int)

pub fn CSurf_OnRewFwd(&self, seekplay: c_int, dir: c_int)

pub fn CSurf_OnScroll(&self, xdir: c_int, ydir: c_int)

pub unsafe fn CSurf_OnSelectedChange(
    &self,
    trackid: *mut MediaTrack,
    selected: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnSendPanChange(
    &self,
    trackid: *mut MediaTrack,
    send_index: c_int,
    pan: f64,
    relative: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnSendVolumeChange(
    &self,
    trackid: *mut MediaTrack,
    send_index: c_int,
    volume: f64,
    relative: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnSoloChange(
    &self,
    trackid: *mut MediaTrack,
    solo: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnSoloChangeEx(
    &self,
    trackid: *mut MediaTrack,
    solo: c_int,
    allowgang: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn CSurf_OnStop(&self)

pub fn CSurf_OnTempoChange(&self, bpm: f64)

pub unsafe fn CSurf_OnTrackSelection(&self, trackid: *mut MediaTrack)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnVolumeChange(
    &self,
    trackid: *mut MediaTrack,
    volume: f64,
    relative: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnVolumeChangeEx(
    &self,
    trackid: *mut MediaTrack,
    volume: f64,
    relative: bool,
    allowGang: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnWidthChange(
    &self,
    trackid: *mut MediaTrack,
    width: f64,
    relative: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_OnWidthChangeEx(
    &self,
    trackid: *mut MediaTrack,
    width: f64,
    relative: bool,
    allowGang: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub fn CSurf_OnZoom(&self, xdir: c_int, ydir: c_int)

pub fn CSurf_ResetAllCachedVolPanStates(&self)

pub fn CSurf_ScrubAmt(&self, amt: f64)

pub unsafe fn CSurf_SetAutoMode(
    &self,
    mode: c_int,
    ignoresurf: *mut IReaperControlSurface
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_SetPlayState(
    &self,
    play: bool,
    pause: bool,
    rec: bool,
    ignoresurf: *mut IReaperControlSurface
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_SetRepeatState(
    &self,
    rep: bool,
    ignoresurf: *mut IReaperControlSurface
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_SetSurfaceMute(
    &self,
    trackid: *mut MediaTrack,
    mute: bool,
    ignoresurf: *mut IReaperControlSurface
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_SetSurfacePan(
    &self,
    trackid: *mut MediaTrack,
    pan: f64,
    ignoresurf: *mut IReaperControlSurface
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_SetSurfaceRecArm(
    &self,
    trackid: *mut MediaTrack,
    recarm: bool,
    ignoresurf: *mut IReaperControlSurface
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_SetSurfaceSelected(
    &self,
    trackid: *mut MediaTrack,
    selected: bool,
    ignoresurf: *mut IReaperControlSurface
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_SetSurfaceSolo(
    &self,
    trackid: *mut MediaTrack,
    solo: bool,
    ignoresurf: *mut IReaperControlSurface
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CSurf_SetSurfaceVolume(
    &self,
    trackid: *mut MediaTrack,
    volume: f64,
    ignoresurf: *mut IReaperControlSurface
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn CSurf_SetTrackListChange(&self)

pub fn CSurf_TrackFromID(&self, idx: c_int, mcpView: bool) -> *mut MediaTrack

pub unsafe fn CSurf_TrackToID(
    &self,
    track: *mut MediaTrack,
    mcpView: bool
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn DB2SLIDER(&self, x: f64) -> f64

pub unsafe fn DeleteActionShortcut(
    &self,
    section: *mut KbdSectionInfo,
    cmdID: c_int,
    shortcutidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteEnvelopePointEx(
    &self,
    envelope: *mut TrackEnvelope,
    autoitem_idx: c_int,
    ptidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteEnvelopePointRange(
    &self,
    envelope: *mut TrackEnvelope,
    time_start: f64,
    time_end: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteEnvelopePointRangeEx(
    &self,
    envelope: *mut TrackEnvelope,
    autoitem_idx: c_int,
    time_start: f64,
    time_end: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteExtState(
    &self,
    section: *const c_char,
    key: *const c_char,
    persist: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteProjectMarker(
    &self,
    proj: *mut ReaProject,
    markrgnindexnumber: c_int,
    isrgn: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteProjectMarkerByIndex(
    &self,
    proj: *mut ReaProject,
    markrgnidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteTakeMarker(
    &self,
    take: *mut MediaItem_Take,
    idx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteTakeStretchMarkers(
    &self,
    take: *mut MediaItem_Take,
    idx: c_int,
    countInOptional: *const c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteTempoTimeSigMarker(
    &self,
    project: *mut ReaProject,
    markerindex: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteTrack(&self, tr: *mut MediaTrack)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DeleteTrackMediaItem(
    &self,
    tr: *mut MediaTrack,
    it: *mut MediaItem
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DestroyAudioAccessor(&self, accessor: *mut AudioAccessor)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DestroyLocalOscHandler(&self, local_osc_handler: *mut c_void)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DoActionShortcutDialog(
    &self,
    hwnd: HWND,
    section: *mut KbdSectionInfo,
    cmdID: c_int,
    shortcutidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Dock_UpdateDockID(&self, ident_str: *const c_char, whichDock: c_int)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn DockGetPosition(&self, whichDock: c_int) -> c_int

pub unsafe fn DockIsChildOfDock(
    &self,
    hwnd: HWND,
    isFloatingDockerOut: *mut bool
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DockWindowActivate(&self, hwnd: HWND)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DockWindowAdd(
    &self,
    hwnd: HWND,
    name: *const c_char,
    pos: c_int,
    allowShow: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DockWindowAddEx(
    &self,
    hwnd: HWND,
    name: *const c_char,
    identstr: *const c_char,
    allowShow: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn DockWindowRefresh(&self)

pub unsafe fn DockWindowRefreshForHWND(&self, hwnd: HWND)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DockWindowRemove(&self, hwnd: HWND)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn DuplicateCustomizableMenu(
    &self,
    srcmenu: *mut c_void,
    destmenu: *mut c_void
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EditTempoTimeSigMarker(
    &self,
    project: *mut ReaProject,
    markerindex: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnsureNotCompletelyOffscreen(&self, rInOut: *mut RECT)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumerateFiles(
    &self,
    path: *const c_char,
    fileindex: c_int
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumerateSubdirectories(
    &self,
    path: *const c_char,
    subdirindex: c_int
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumPitchShiftModes(
    &self,
    mode: c_int,
    strOut: *mut *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn EnumPitchShiftSubModes(&self, mode: c_int, submode: c_int) -> *const c_char

pub unsafe fn EnumProjectMarkers(
    &self,
    idx: c_int,
    isrgnOut: *mut bool,
    posOut: *mut f64,
    rgnendOut: *mut f64,
    nameOut: *mut *const c_char,
    markrgnindexnumberOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumProjectMarkers2(
    &self,
    proj: *mut ReaProject,
    idx: c_int,
    isrgnOut: *mut bool,
    posOut: *mut f64,
    rgnendOut: *mut f64,
    nameOut: *mut *const c_char,
    markrgnindexnumberOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumProjectMarkers3(
    &self,
    proj: *mut ReaProject,
    idx: c_int,
    isrgnOut: *mut bool,
    posOut: *mut f64,
    rgnendOut: *mut f64,
    nameOut: *mut *const c_char,
    markrgnindexnumberOut: *mut c_int,
    colorOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumProjects(
    &self,
    idx: c_int,
    projfnOutOptional: *mut c_char,
    projfnOutOptional_sz: c_int
) -> *mut ReaProject

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumProjExtState(
    &self,
    proj: *mut ReaProject,
    extname: *const c_char,
    idx: c_int,
    keyOutOptional: *mut c_char,
    keyOutOptional_sz: c_int,
    valOutOptional: *mut c_char,
    valOutOptional_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumRegionRenderMatrix(
    &self,
    proj: *mut ReaProject,
    regionindex: c_int,
    rendertrack: c_int
) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumTrackMIDIProgramNames(
    &self,
    track: c_int,
    programNumber: c_int,
    programName: *mut c_char,
    programName_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn EnumTrackMIDIProgramNamesEx(
    &self,
    proj: *mut ReaProject,
    track: *mut MediaTrack,
    programNumber: c_int,
    programName: *mut c_char,
    programName_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Envelope_Evaluate(
    &self,
    envelope: *mut TrackEnvelope,
    time: f64,
    samplerate: f64,
    samplesRequested: c_int,
    valueOut: *mut f64,
    dVdSOut: *mut f64,
    ddVdSOut: *mut f64,
    dddVdSOut: *mut f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Envelope_FormatValue(
    &self,
    env: *mut TrackEnvelope,
    value: f64,
    bufOut: *mut c_char,
    bufOut_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Envelope_GetParentTake(
    &self,
    env: *mut TrackEnvelope,
    indexOut: *mut c_int,
    index2Out: *mut c_int
) -> *mut MediaItem_Take

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Envelope_GetParentTrack(
    &self,
    env: *mut TrackEnvelope,
    indexOut: *mut c_int,
    index2Out: *mut c_int
) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Envelope_SortPoints(&self, envelope: *mut TrackEnvelope) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Envelope_SortPointsEx(
    &self,
    envelope: *mut TrackEnvelope,
    autoitem_idx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ExecProcess(
    &self,
    cmdline: *const c_char,
    timeoutmsec: c_int
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn file_exists(&self, path: *const c_char) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn FindTempoTimeSigMarker(
    &self,
    project: *mut ReaProject,
    time: f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn format_timestr(&self, tpos: f64, buf: *mut c_char, buf_sz: c_int)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn format_timestr_len(
    &self,
    tpos: f64,
    buf: *mut c_char,
    buf_sz: c_int,
    offset: f64,
    modeoverride: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn format_timestr_pos(
    &self,
    tpos: f64,
    buf: *mut c_char,
    buf_sz: c_int,
    modeoverride: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn FreeHeapPtr(&self, ptr: *mut c_void)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn genGuid(&self, g: *mut GUID)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn get_config_var(
    &self,
    name: *const c_char,
    szOut: *mut c_int
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn get_config_var_string(
    &self,
    name: *const c_char,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn get_ini_file(&self) -> *const c_char

pub unsafe fn get_midi_config_var(
    &self,
    name: *const c_char,
    szOut: *mut c_int
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetActionShortcutDesc(
    &self,
    section: *mut KbdSectionInfo,
    cmdID: c_int,
    shortcutidx: c_int,
    desc: *mut c_char,
    desclen: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetActiveTake(&self, item: *mut MediaItem) -> *mut MediaItem_Take

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetAllProjectPlayStates(
    &self,
    ignoreProject: *mut ReaProject
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetAppVersion(&self) -> *const c_char

pub unsafe fn GetArmedCommand(
    &self,
    secOut: *mut c_char,
    secOut_sz: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetAudioAccessorEndTime(&self, accessor: *mut AudioAccessor) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetAudioAccessorHash(
    &self,
    accessor: *mut AudioAccessor,
    hashNeed128: *mut c_char
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetAudioAccessorSamples(
    &self,
    accessor: *mut AudioAccessor,
    samplerate: c_int,
    numchannels: c_int,
    starttime_sec: f64,
    numsamplesperchannel: c_int,
    samplebuffer: *mut f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetAudioAccessorStartTime(
    &self,
    accessor: *mut AudioAccessor
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetAudioDeviceInfo(
    &self,
    attribute: *const c_char,
    descOut: *mut c_char,
    descOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetColorTheme(&self, idx: c_int, defval: c_int) -> INT_PTR

pub unsafe fn GetColorThemeStruct(&self, szOut: *mut c_int) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetConfigWantsDock(&self, ident_str: *const c_char) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetContextMenu(&self, idx: c_int) -> HMENU

pub fn GetCurrentProjectInLoadSave(&self) -> *mut ReaProject

pub fn GetCursorContext(&self) -> c_int

pub fn GetCursorContext2(&self, want_last_valid: bool) -> c_int

pub fn GetCursorPosition(&self) -> f64

pub unsafe fn GetCursorPositionEx(&self, proj: *mut ReaProject) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetDisplayedMediaItemColor(&self, item: *mut MediaItem) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetDisplayedMediaItemColor2(
    &self,
    item: *mut MediaItem,
    take: *mut MediaItem_Take
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetEnvelopeInfo_Value(
    &self,
    env: *mut TrackEnvelope,
    parmname: *const c_char
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetEnvelopeName(
    &self,
    env: *mut TrackEnvelope,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetEnvelopePoint(
    &self,
    envelope: *mut TrackEnvelope,
    ptidx: c_int,
    timeOut: *mut f64,
    valueOut: *mut f64,
    shapeOut: *mut c_int,
    tensionOut: *mut f64,
    selectedOut: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetEnvelopePointByTime(
    &self,
    envelope: *mut TrackEnvelope,
    time: f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetEnvelopePointByTimeEx(
    &self,
    envelope: *mut TrackEnvelope,
    autoitem_idx: c_int,
    time: f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetEnvelopePointEx(
    &self,
    envelope: *mut TrackEnvelope,
    autoitem_idx: c_int,
    ptidx: c_int,
    timeOut: *mut f64,
    valueOut: *mut f64,
    shapeOut: *mut c_int,
    tensionOut: *mut f64,
    selectedOut: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetEnvelopeScalingMode(&self, env: *mut TrackEnvelope) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetEnvelopeStateChunk(
    &self,
    env: *mut TrackEnvelope,
    strNeedBig: *mut c_char,
    strNeedBig_sz: c_int,
    isundoOptional: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetEnvelopeUIState(&self, env: *mut TrackEnvelope) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetExePath(&self) -> *const c_char

pub unsafe fn GetExtState(
    &self,
    section: *const c_char,
    key: *const c_char
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetFocusedFX(
    &self,
    tracknumberOut: *mut c_int,
    itemnumberOut: *mut c_int,
    fxnumberOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetFocusedFX2(
    &self,
    tracknumberOut: *mut c_int,
    itemnumberOut: *mut c_int,
    fxnumberOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetFreeDiskSpaceForRecordPath(
    &self,
    proj: *mut ReaProject,
    pathidx: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetFXEnvelope(
    &self,
    track: *mut MediaTrack,
    fxindex: c_int,
    parameterindex: c_int,
    create: bool
) -> *mut TrackEnvelope

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetGlobalAutomationOverride(&self) -> c_int

pub fn GetHZoomLevel(&self) -> f64

pub unsafe fn GetIconThemePointer(&self, name: *const c_char) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetIconThemePointerForDPI(
    &self,
    name: *const c_char,
    dpisc: c_int
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetIconThemeStruct(&self, szOut: *mut c_int) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetInputChannelName(&self, channelIndex: c_int) -> *const c_char

pub unsafe fn GetInputOutputLatency(
    &self,
    inputlatencyOut: *mut c_int,
    outputLatencyOut: *mut c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetItemEditingTime2(
    &self,
    which_itemOut: *mut *mut PCM_source,
    flagsOut: *mut c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetItemFromPoint(
    &self,
    screen_x: c_int,
    screen_y: c_int,
    allow_locked: bool,
    takeOutOptional: *mut *mut MediaItem_Take
) -> *mut MediaItem

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetItemProjectContext(
    &self,
    item: *mut MediaItem
) -> *mut ReaProject

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetItemStateChunk(
    &self,
    item: *mut MediaItem,
    strNeedBig: *mut c_char,
    strNeedBig_sz: c_int,
    isundoOptional: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetLastColorThemeFile(&self) -> *const c_char

pub unsafe fn GetLastMarkerAndCurRegion(
    &self,
    proj: *mut ReaProject,
    time: f64,
    markeridxOut: *mut c_int,
    regionidxOut: *mut c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetLastTouchedFX(
    &self,
    tracknumberOut: *mut c_int,
    fxnumberOut: *mut c_int,
    paramnumberOut: *mut c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetLastTouchedTrack(&self) -> *mut MediaTrack

pub fn GetMainHwnd(&self) -> HWND

pub fn GetMasterMuteSoloFlags(&self) -> c_int

pub unsafe fn GetMasterTrack(&self, proj: *mut ReaProject) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetMasterTrackVisibility(&self) -> c_int

pub fn GetMaxMidiInputs(&self) -> c_int

pub fn GetMaxMidiOutputs(&self) -> c_int

pub unsafe fn GetMediaFileMetadata(
    &self,
    mediaSource: *mut PCM_source,
    identifier: *const c_char,
    bufOutNeedBig: *mut c_char,
    bufOutNeedBig_sz: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItem(
    &self,
    proj: *mut ReaProject,
    itemidx: c_int
) -> *mut MediaItem

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItem_Track(&self, item: *mut MediaItem) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemInfo_Value(
    &self,
    item: *mut MediaItem,
    parmname: *const c_char
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemNumTakes(&self, item: *mut MediaItem) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemTake(
    &self,
    item: *mut MediaItem,
    tk: c_int
) -> *mut MediaItem_Take

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemTake_Item(
    &self,
    take: *mut MediaItem_Take
) -> *mut MediaItem

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemTake_Peaks(
    &self,
    take: *mut MediaItem_Take,
    peakrate: f64,
    starttime: f64,
    numchannels: c_int,
    numsamplesperchannel: c_int,
    want_extra_type: c_int,
    buf: *mut f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemTake_Source(
    &self,
    take: *mut MediaItem_Take
) -> *mut PCM_source

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemTake_Track(
    &self,
    take: *mut MediaItem_Take
) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemTakeByGUID(
    &self,
    project: *mut ReaProject,
    guid: *const GUID
) -> *mut MediaItem_Take

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemTakeInfo_Value(
    &self,
    take: *mut MediaItem_Take,
    parmname: *const c_char
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaItemTrack(&self, item: *mut MediaItem) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaSourceFileName(
    &self,
    source: *mut PCM_source,
    filenamebufOut: *mut c_char,
    filenamebufOut_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaSourceLength(
    &self,
    source: *mut PCM_source,
    lengthIsQNOut: *mut bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaSourceNumChannels(&self, source: *mut PCM_source) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaSourceParent(
    &self,
    src: *mut PCM_source
) -> *mut PCM_source

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaSourceSampleRate(&self, source: *mut PCM_source) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaSourceType(
    &self,
    source: *mut PCM_source,
    typebufOut: *mut c_char,
    typebufOut_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMediaTrackInfo_Value(
    &self,
    tr: *mut MediaTrack,
    parmname: *const c_char
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMIDIInputName(
    &self,
    dev: c_int,
    nameout: *mut c_char,
    nameout_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMIDIOutputName(
    &self,
    dev: c_int,
    nameout: *mut c_char,
    nameout_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetMixerScroll(&self) -> *mut MediaTrack

pub unsafe fn GetMouseModifier(
    &self,
    context: *const c_char,
    modifier_flag: c_int,
    actionOut: *mut c_char,
    actionOut_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetMousePosition(&self, xOut: *mut c_int, yOut: *mut c_int)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetNumAudioInputs(&self) -> c_int

pub fn GetNumAudioOutputs(&self) -> c_int

pub fn GetNumMIDIInputs(&self) -> c_int

pub fn GetNumMIDIOutputs(&self) -> c_int

pub unsafe fn GetNumTakeMarkers(&self, take: *mut MediaItem_Take) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetNumTracks(&self) -> c_int

pub fn GetOS(&self) -> *const c_char

pub fn GetOutputChannelName(&self, channelIndex: c_int) -> *const c_char

pub fn GetOutputLatency(&self) -> f64

pub unsafe fn GetParentTrack(&self, track: *mut MediaTrack) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetPeakFileName(
    &self,
    fn_: *const c_char,
    bufOut: *mut c_char,
    bufOut_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetPeakFileNameEx(
    &self,
    fn_: *const c_char,
    buf: *mut c_char,
    buf_sz: c_int,
    forWrite: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetPeakFileNameEx2(
    &self,
    fn_: *const c_char,
    buf: *mut c_char,
    buf_sz: c_int,
    forWrite: bool,
    peaksfileextension: *const c_char
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetPeaksBitmap(
    &self,
    pks: *mut PCM_source_peaktransfer_t,
    maxamp: f64,
    w: c_int,
    h: c_int,
    bmp: *mut LICE_IBitmap
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetPlayPosition(&self) -> f64

pub fn GetPlayPosition2(&self) -> f64

pub unsafe fn GetPlayPosition2Ex(&self, proj: *mut ReaProject) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetPlayPositionEx(&self, proj: *mut ReaProject) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetPlayState(&self) -> c_int

pub unsafe fn GetPlayStateEx(&self, proj: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetPreferredDiskReadMode(
    &self,
    mode: *mut c_int,
    nb: *mut c_int,
    bs: *mut c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetPreferredDiskReadModePeak(
    &self,
    mode: *mut c_int,
    nb: *mut c_int,
    bs: *mut c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetPreferredDiskWriteMode(
    &self,
    mode: *mut c_int,
    nb: *mut c_int,
    bs: *mut c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetProjectLength(&self, proj: *mut ReaProject) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetProjectName(
    &self,
    proj: *mut ReaProject,
    bufOut: *mut c_char,
    bufOut_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetProjectPath(&self, bufOut: *mut c_char, bufOut_sz: c_int)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetProjectPathEx(
    &self,
    proj: *mut ReaProject,
    bufOut: *mut c_char,
    bufOut_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetProjectStateChangeCount(&self, proj: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetProjectTimeOffset(
    &self,
    proj: *mut ReaProject,
    rndframe: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetProjectTimeSignature(&self, bpmOut: *mut f64, bpiOut: *mut f64)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetProjectTimeSignature2(
    &self,
    proj: *mut ReaProject,
    bpmOut: *mut f64,
    bpiOut: *mut f64
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetProjExtState(
    &self,
    proj: *mut ReaProject,
    extname: *const c_char,
    key: *const c_char,
    valOutNeedBig: *mut c_char,
    valOutNeedBig_sz: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetResourcePath(&self) -> *const c_char

pub unsafe fn GetSelectedEnvelope(
    &self,
    proj: *mut ReaProject
) -> *mut TrackEnvelope

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSelectedMediaItem(
    &self,
    proj: *mut ReaProject,
    selitem: c_int
) -> *mut MediaItem

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSelectedTrack(
    &self,
    proj: *mut ReaProject,
    seltrackidx: c_int
) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSelectedTrack2(
    &self,
    proj: *mut ReaProject,
    seltrackidx: c_int,
    wantmaster: bool
) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSelectedTrackEnvelope(
    &self,
    proj: *mut ReaProject
) -> *mut TrackEnvelope

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSet_ArrangeView2(
    &self,
    proj: *mut ReaProject,
    isSet: bool,
    screen_x_start: c_int,
    screen_x_end: c_int,
    start_timeInOut: *mut f64,
    end_timeInOut: *mut f64
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSet_LoopTimeRange(
    &self,
    isSet: bool,
    isLoop: bool,
    startOut: *mut f64,
    endOut: *mut f64,
    allowautoseek: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSet_LoopTimeRange2(
    &self,
    proj: *mut ReaProject,
    isSet: bool,
    isLoop: bool,
    startOut: *mut f64,
    endOut: *mut f64,
    allowautoseek: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetAutomationItemInfo(
    &self,
    env: *mut TrackEnvelope,
    autoitem_idx: c_int,
    desc: *const c_char,
    value: f64,
    is_set: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetAutomationItemInfo_String(
    &self,
    env: *mut TrackEnvelope,
    autoitem_idx: c_int,
    desc: *const c_char,
    valuestrNeedBig: *mut c_char,
    is_set: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetEnvelopeInfo_String(
    &self,
    env: *mut TrackEnvelope,
    parmname: *const c_char,
    stringNeedBig: *mut c_char,
    setNewValue: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetEnvelopeState(
    &self,
    env: *mut TrackEnvelope,
    str: *mut c_char,
    str_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetEnvelopeState2(
    &self,
    env: *mut TrackEnvelope,
    str: *mut c_char,
    str_sz: c_int,
    isundo: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetItemState(
    &self,
    item: *mut MediaItem,
    str: *mut c_char,
    str_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetItemState2(
    &self,
    item: *mut MediaItem,
    str: *mut c_char,
    str_sz: c_int,
    isundo: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetMediaItemInfo(
    &self,
    item: *mut MediaItem,
    parmname: *const c_char,
    setNewValue: *mut c_void
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetMediaItemInfo_String(
    &self,
    item: *mut MediaItem,
    parmname: *const c_char,
    stringNeedBig: *mut c_char,
    setNewValue: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetMediaItemTakeInfo(
    &self,
    tk: *mut MediaItem_Take,
    parmname: *const c_char,
    setNewValue: *mut c_void
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetMediaItemTakeInfo_String(
    &self,
    tk: *mut MediaItem_Take,
    parmname: *const c_char,
    stringNeedBig: *mut c_char,
    setNewValue: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetMediaTrackInfo(
    &self,
    tr: *mut MediaTrack,
    parmname: *const c_char,
    setNewValue: *mut c_void
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetMediaTrackInfo_String(
    &self,
    tr: *mut MediaTrack,
    parmname: *const c_char,
    stringNeedBig: *mut c_char,
    setNewValue: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetObjectState(
    &self,
    obj: *mut c_void,
    str: *const c_char
) -> *mut c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetObjectState2(
    &self,
    obj: *mut c_void,
    str: *const c_char,
    isundo: bool
) -> *mut c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetProjectAuthor(
    &self,
    proj: *mut ReaProject,
    set: bool,
    author: *mut c_char,
    author_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetProjectGrid(
    &self,
    project: *mut ReaProject,
    set: bool,
    divisionInOutOptional: *mut f64,
    swingmodeInOutOptional: *mut c_int,
    swingamtInOutOptional: *mut f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetProjectInfo(
    &self,
    project: *mut ReaProject,
    desc: *const c_char,
    value: f64,
    is_set: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetProjectInfo_String(
    &self,
    project: *mut ReaProject,
    desc: *const c_char,
    valuestrNeedBig: *mut c_char,
    is_set: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetProjectNotes(
    &self,
    proj: *mut ReaProject,
    set: bool,
    notesNeedBig: *mut c_char,
    notesNeedBig_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetSetRepeat(&self, val: c_int) -> c_int

pub unsafe fn GetSetRepeatEx(&self, proj: *mut ReaProject, val: c_int) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetTrackGroupMembership(
    &self,
    tr: *mut MediaTrack,
    groupname: *const c_char,
    setmask: c_uint,
    setvalue: c_uint
) -> c_uint

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetTrackGroupMembershipHigh(
    &self,
    tr: *mut MediaTrack,
    groupname: *const c_char,
    setmask: c_uint,
    setvalue: c_uint
) -> c_uint

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetTrackMIDISupportFile(
    &self,
    proj: *mut ReaProject,
    track: *mut MediaTrack,
    which: c_int,
    filename: *const c_char
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetTrackSendInfo(
    &self,
    tr: *mut MediaTrack,
    category: c_int,
    sendidx: c_int,
    parmname: *const c_char,
    setNewValue: *mut c_void
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetTrackSendInfo_String(
    &self,
    tr: *mut MediaTrack,
    category: c_int,
    sendidx: c_int,
    parmname: *const c_char,
    stringNeedBig: *mut c_char,
    setNewValue: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetTrackState(
    &self,
    track: *mut MediaTrack,
    str: *mut c_char,
    str_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSetTrackState2(
    &self,
    track: *mut MediaTrack,
    str: *mut c_char,
    str_sz: c_int,
    isundo: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetSubProjectFromSource(
    &self,
    src: *mut PCM_source
) -> *mut ReaProject

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTake(
    &self,
    item: *mut MediaItem,
    takeidx: c_int
) -> *mut MediaItem_Take

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTakeEnvelope(
    &self,
    take: *mut MediaItem_Take,
    envidx: c_int
) -> *mut TrackEnvelope

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTakeEnvelopeByName(
    &self,
    take: *mut MediaItem_Take,
    envname: *const c_char
) -> *mut TrackEnvelope

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTakeMarker(
    &self,
    take: *mut MediaItem_Take,
    idx: c_int,
    nameOut: *mut c_char,
    nameOut_sz: c_int,
    colorOutOptional: *mut c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTakeName(&self, take: *mut MediaItem_Take) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTakeNumStretchMarkers(&self, take: *mut MediaItem_Take) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTakeStretchMarker(
    &self,
    take: *mut MediaItem_Take,
    idx: c_int,
    posOut: *mut f64,
    srcposOutOptional: *mut f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTakeStretchMarkerSlope(
    &self,
    take: *mut MediaItem_Take,
    idx: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTCPFXParm(
    &self,
    project: *mut ReaProject,
    track: *mut MediaTrack,
    index: c_int,
    fxindexOut: *mut c_int,
    parmidxOut: *mut c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTempoMatchPlayRate(
    &self,
    source: *mut PCM_source,
    srcscale: f64,
    position: f64,
    mult: f64,
    rateOut: *mut f64,
    targetlenOut: *mut f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTempoTimeSigMarker(
    &self,
    proj: *mut ReaProject,
    ptidx: c_int,
    timeposOut: *mut f64,
    measureposOut: *mut c_int,
    beatposOut: *mut f64,
    bpmOut: *mut f64,
    timesig_numOut: *mut c_int,
    timesig_denomOut: *mut c_int,
    lineartempoOut: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetThemeColor(
    &self,
    ini_key: *const c_char,
    flagsOptional: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetThingFromPoint(
    &self,
    screen_x: c_int,
    screen_y: c_int,
    infoOut: *mut c_char,
    infoOut_sz: c_int
) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetToggleCommandState(&self, command_id: c_int) -> c_int

pub unsafe fn GetToggleCommandState2(
    &self,
    section: *mut KbdSectionInfo,
    command_id: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetToggleCommandStateEx(
    &self,
    section_id: c_int,
    command_id: c_int
) -> c_int

pub unsafe fn GetToggleCommandStateThroughHooks(
    &self,
    section: *mut KbdSectionInfo,
    command_id: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetTooltipWindow(&self) -> HWND

pub unsafe fn GetTrack(
    &self,
    proj: *mut ReaProject,
    trackidx: c_int
) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackAutomationMode(&self, tr: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackColor(&self, track: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackDepth(&self, track: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackEnvelope(
    &self,
    track: *mut MediaTrack,
    envidx: c_int
) -> *mut TrackEnvelope

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackEnvelopeByChunkName(
    &self,
    tr: *mut MediaTrack,
    cfgchunkname_or_guid: *const c_char
) -> *mut TrackEnvelope

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackEnvelopeByName(
    &self,
    track: *mut MediaTrack,
    envname: *const c_char
) -> *mut TrackEnvelope

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackFromPoint(
    &self,
    screen_x: c_int,
    screen_y: c_int,
    infoOutOptional: *mut c_int
) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackGUID(&self, tr: *mut MediaTrack) -> *mut GUID

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackInfo(
    &self,
    track: INT_PTR,
    flags: *mut c_int
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackMediaItem(
    &self,
    tr: *mut MediaTrack,
    itemidx: c_int
) -> *mut MediaItem

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackMIDILyrics(
    &self,
    track: *mut MediaTrack,
    flag: c_int,
    bufOutWantNeedBig: *mut c_char,
    bufOutWantNeedBig_sz: *mut c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetTrackMIDINoteName(
    &self,
    track: c_int,
    pitch: c_int,
    chan: c_int
) -> *const c_char

pub unsafe fn GetTrackMIDINoteNameEx(
    &self,
    proj: *mut ReaProject,
    track: *mut MediaTrack,
    pitch: c_int,
    chan: c_int
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackMIDINoteRange(
    &self,
    proj: *mut ReaProject,
    track: *mut MediaTrack,
    note_loOut: *mut c_int,
    note_hiOut: *mut c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackName(
    &self,
    track: *mut MediaTrack,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackNumMediaItems(&self, tr: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackNumSends(
    &self,
    tr: *mut MediaTrack,
    category: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackReceiveName(
    &self,
    track: *mut MediaTrack,
    recv_index: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackReceiveUIMute(
    &self,
    track: *mut MediaTrack,
    recv_index: c_int,
    muteOut: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackReceiveUIVolPan(
    &self,
    track: *mut MediaTrack,
    recv_index: c_int,
    volumeOut: *mut f64,
    panOut: *mut f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackSendInfo_Value(
    &self,
    tr: *mut MediaTrack,
    category: c_int,
    sendidx: c_int,
    parmname: *const c_char
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackSendName(
    &self,
    track: *mut MediaTrack,
    send_index: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackSendUIMute(
    &self,
    track: *mut MediaTrack,
    send_index: c_int,
    muteOut: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackSendUIVolPan(
    &self,
    track: *mut MediaTrack,
    send_index: c_int,
    volumeOut: *mut f64,
    panOut: *mut f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackState(
    &self,
    track: *mut MediaTrack,
    flagsOut: *mut c_int
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackStateChunk(
    &self,
    track: *mut MediaTrack,
    strNeedBig: *mut c_char,
    strNeedBig_sz: c_int,
    isundoOptional: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackUIMute(
    &self,
    track: *mut MediaTrack,
    muteOut: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackUIPan(
    &self,
    track: *mut MediaTrack,
    pan1Out: *mut f64,
    pan2Out: *mut f64,
    panmodeOut: *mut c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetTrackUIVolPan(
    &self,
    track: *mut MediaTrack,
    volumeOut: *mut f64,
    panOut: *mut f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetUnderrunTime(
    &self,
    audio_xrunOut: *mut c_uint,
    media_xrunOut: *mut c_uint,
    curtimeOut: *mut c_uint
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetUserFileNameForRead(
    &self,
    filenameNeed4096: *mut c_char,
    title: *const c_char,
    defext: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GetUserInputs(
    &self,
    title: *const c_char,
    num_inputs: c_int,
    captions_csv: *const c_char,
    retvals_csv: *mut c_char,
    retvals_csv_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GoToMarker(
    &self,
    proj: *mut ReaProject,
    marker_index: c_int,
    use_timeline_order: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GoToRegion(
    &self,
    proj: *mut ReaProject,
    region_index: c_int,
    use_timeline_order: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn GR_SelectColor(&self, hwnd: HWND, colorOut: *mut c_int) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GSC_mainwnd(&self, t: c_int) -> c_int

pub unsafe fn guidToString(&self, g: *const GUID, destNeed64: *mut c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn HasExtState(
    &self,
    section: *const c_char,
    key: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn HasTrackMIDIPrograms(&self, track: c_int) -> *const c_char

pub unsafe fn HasTrackMIDIProgramsEx(
    &self,
    proj: *mut ReaProject,
    track: *mut MediaTrack
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Help_Set(&self, helpstring: *const c_char, is_temporary_help: bool)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn HiresPeaksFromSource(
    &self,
    src: *mut PCM_source,
    block: *mut PCM_source_peaktransfer_t
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn image_resolve_fn(
    &self,
    in_: *const c_char,
    out: *mut c_char,
    out_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn InsertAutomationItem(
    &self,
    env: *mut TrackEnvelope,
    pool_id: c_int,
    position: f64,
    length: f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn InsertEnvelopePoint(
    &self,
    envelope: *mut TrackEnvelope,
    time: f64,
    value: f64,
    shape: c_int,
    tension: f64,
    selected: bool,
    noSortInOptional: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn InsertEnvelopePointEx(
    &self,
    envelope: *mut TrackEnvelope,
    autoitem_idx: c_int,
    time: f64,
    value: f64,
    shape: c_int,
    tension: f64,
    selected: bool,
    noSortInOptional: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn InsertMedia(&self, file: *const c_char, mode: c_int) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn InsertMediaSection(
    &self,
    file: *const c_char,
    mode: c_int,
    startpct: f64,
    endpct: f64,
    pitchshift: f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn InsertTrackAtIndex(&self, idx: c_int, wantDefaults: bool)

pub fn IsInRealTimeAudio(&self) -> c_int

pub unsafe fn IsItemTakeActiveForPlayback(
    &self,
    item: *mut MediaItem,
    take: *mut MediaItem_Take
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn IsMediaExtension(
    &self,
    ext: *const c_char,
    wantOthers: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn IsMediaItemSelected(&self, item: *mut MediaItem) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn IsProjectDirty(&self, proj: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn IsREAPER(&self) -> bool

pub unsafe fn IsTrackSelected(&self, track: *mut MediaTrack) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn IsTrackVisible(&self, track: *mut MediaTrack, mixer: bool) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn joystick_create(&self, guid: *const GUID) -> *mut joystick_device

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn joystick_destroy(&self, device: *mut joystick_device)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn joystick_enum(
    &self,
    index: c_int,
    namestrOutOptional: *mut *const c_char
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn joystick_getaxis(
    &self,
    dev: *mut joystick_device,
    axis: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn joystick_getbuttonmask(&self, dev: *mut joystick_device) -> c_uint

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn joystick_getinfo(
    &self,
    dev: *mut joystick_device,
    axesOutOptional: *mut c_int,
    povsOutOptional: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn joystick_getpov(&self, dev: *mut joystick_device, pov: c_int) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn joystick_update(&self, dev: *mut joystick_device) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_enumerateActions(
    &self,
    section: *mut KbdSectionInfo,
    idx: c_int,
    nameOut: *mut *const c_char
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_formatKeyName(&self, ac: *mut ACCEL, s: *mut c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_getCommandName(
    &self,
    cmd: c_int,
    s: *mut c_char,
    section: *mut KbdSectionInfo
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_getTextFromCmd(
    &self,
    cmd: c_int,
    section: *mut KbdSectionInfo
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn KBD_OnMainActionEx(
    &self,
    cmd: c_int,
    val: c_int,
    valhw: c_int,
    relmode: c_int,
    hwnd: HWND,
    proj: *mut ReaProject
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_OnMidiEvent(&self, evt: *mut MIDI_event_t, dev_index: c_int)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_OnMidiList(&self, list: *mut MIDI_eventlist, dev_index: c_int)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_ProcessActionsMenu(
    &self,
    menu: HMENU,
    section: *mut KbdSectionInfo
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_processMidiEventActionEx(
    &self,
    evt: *mut MIDI_event_t,
    section: *mut KbdSectionInfo,
    hwndCtx: HWND
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_reprocessMenu(&self, menu: HMENU, section: *mut KbdSectionInfo)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_RunCommandThroughHooks(
    &self,
    section: *mut KbdSectionInfo,
    actionCommandID: *const c_int,
    val: *const c_int,
    valhw: *const c_int,
    relmode: *const c_int,
    hwnd: HWND
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_translateAccelerator(
    &self,
    hwnd: HWND,
    msg: *mut MSG,
    section: *mut KbdSectionInfo
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn kbd_translateMouse(
    &self,
    winmsg: *mut c_void,
    midimsg: *mut c_uchar
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__Destroy(&self, bm: *mut LICE_IBitmap)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__DestroyFont(&self, font: *mut LICE_IFont)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__DrawText(
    &self,
    font: *mut LICE_IFont,
    bm: *mut LICE_IBitmap,
    str: *const c_char,
    strcnt: c_int,
    rect: *mut RECT,
    dtFlags: UINT
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__GetBits(&self, bm: *mut LICE_IBitmap) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__GetDC(&self, bm: *mut LICE_IBitmap) -> HDC

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__GetHeight(&self, bm: *mut LICE_IBitmap) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__GetRowSpan(&self, bm: *mut LICE_IBitmap) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__GetWidth(&self, bm: *mut LICE_IBitmap) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__IsFlipped(&self, bm: *mut LICE_IBitmap) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__resize(
    &self,
    bm: *mut LICE_IBitmap,
    w: c_int,
    h: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__SetBkColor(
    &self,
    font: *mut LICE_IFont,
    color: c_uint
) -> c_uint

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__SetFromHFont(
    &self,
    font: *mut LICE_IFont,
    hfont: *mut HGDIOBJ__,
    flags: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__SetTextColor(
    &self,
    font: *mut LICE_IFont,
    color: c_uint
) -> c_uint

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE__SetTextCombineMode(
    &self,
    ifont: *mut LICE_IFont,
    mode: c_int,
    alpha: f32
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_Arc(
    &self,
    dest: *mut LICE_IBitmap,
    cx: f32,
    cy: f32,
    r: f32,
    minAngle: f32,
    maxAngle: f32,
    color: c_uint,
    alpha: f32,
    mode: c_int,
    aa: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_Blit(
    &self,
    dest: *mut LICE_IBitmap,
    src: *mut LICE_IBitmap,
    dstx: c_int,
    dsty: c_int,
    srcx: c_int,
    srcy: c_int,
    srcw: c_int,
    srch: c_int,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_Blur(
    &self,
    dest: *mut LICE_IBitmap,
    src: *mut LICE_IBitmap,
    dstx: c_int,
    dsty: c_int,
    srcx: c_int,
    srcy: c_int,
    srcw: c_int,
    srch: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_BorderedRect(
    &self,
    dest: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    w: c_int,
    h: c_int,
    bgcolor: c_uint,
    fgcolor: c_uint,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_Circle(
    &self,
    dest: *mut LICE_IBitmap,
    cx: f32,
    cy: f32,
    r: f32,
    color: c_uint,
    alpha: f32,
    mode: c_int,
    aa: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_Clear(&self, dest: *mut LICE_IBitmap, color: c_uint)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_ClearRect(
    &self,
    dest: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    w: c_int,
    h: c_int,
    mask: c_uint,
    orbits: c_uint
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_ClipLine(
    &self,
    pX1Out: *mut c_int,
    pY1Out: *mut c_int,
    pX2Out: *mut c_int,
    pY2Out: *mut c_int,
    xLo: c_int,
    yLo: c_int,
    xHi: c_int,
    yHi: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_Copy(&self, dest: *mut LICE_IBitmap, src: *mut LICE_IBitmap)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn LICE_CreateBitmap(
    &self,
    mode: c_int,
    w: c_int,
    h: c_int
) -> *mut LICE_IBitmap

pub fn LICE_CreateFont(&self) -> *mut LICE_IFont

pub unsafe fn LICE_DrawCBezier(
    &self,
    dest: *mut LICE_IBitmap,
    xstart: f64,
    ystart: f64,
    xctl1: f64,
    yctl1: f64,
    xctl2: f64,
    yctl2: f64,
    xend: f64,
    yend: f64,
    color: c_uint,
    alpha: f32,
    mode: c_int,
    aa: bool,
    tol: f64
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_DrawChar(
    &self,
    bm: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    c: c_char,
    color: c_uint,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_DrawGlyph(
    &self,
    dest: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    color: c_uint,
    alphas: *mut c_uchar,
    glyph_w: c_int,
    glyph_h: c_int,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_DrawRect(
    &self,
    dest: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    w: c_int,
    h: c_int,
    color: c_uint,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_DrawText(
    &self,
    bm: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    string: *const c_char,
    color: c_uint,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_FillCBezier(
    &self,
    dest: *mut LICE_IBitmap,
    xstart: f64,
    ystart: f64,
    xctl1: f64,
    yctl1: f64,
    xctl2: f64,
    yctl2: f64,
    xend: f64,
    yend: f64,
    yfill: c_int,
    color: c_uint,
    alpha: f32,
    mode: c_int,
    aa: bool,
    tol: f64
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_FillCircle(
    &self,
    dest: *mut LICE_IBitmap,
    cx: f32,
    cy: f32,
    r: f32,
    color: c_uint,
    alpha: f32,
    mode: c_int,
    aa: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_FillConvexPolygon(
    &self,
    dest: *mut LICE_IBitmap,
    x: *mut c_int,
    y: *mut c_int,
    npoints: c_int,
    color: c_uint,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_FillRect(
    &self,
    dest: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    w: c_int,
    h: c_int,
    color: c_uint,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_FillTrapezoid(
    &self,
    dest: *mut LICE_IBitmap,
    x1a: c_int,
    x1b: c_int,
    y1: c_int,
    x2a: c_int,
    x2b: c_int,
    y2: c_int,
    color: c_uint,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_FillTriangle(
    &self,
    dest: *mut LICE_IBitmap,
    x1: c_int,
    y1: c_int,
    x2: c_int,
    y2: c_int,
    x3: c_int,
    y3: c_int,
    color: c_uint,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_GetPixel(
    &self,
    bm: *mut LICE_IBitmap,
    x: c_int,
    y: c_int
) -> c_uint

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_GradRect(
    &self,
    dest: *mut LICE_IBitmap,
    dstx: c_int,
    dsty: c_int,
    dstw: c_int,
    dsth: c_int,
    ir: f32,
    ig: f32,
    ib: f32,
    ia: f32,
    drdx: f32,
    dgdx: f32,
    dbdx: f32,
    dadx: f32,
    drdy: f32,
    dgdy: f32,
    dbdy: f32,
    dady: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_Line(
    &self,
    dest: *mut LICE_IBitmap,
    x1: f32,
    y1: f32,
    x2: f32,
    y2: f32,
    color: c_uint,
    alpha: f32,
    mode: c_int,
    aa: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_LineInt(
    &self,
    dest: *mut LICE_IBitmap,
    x1: c_int,
    y1: c_int,
    x2: c_int,
    y2: c_int,
    color: c_uint,
    alpha: f32,
    mode: c_int,
    aa: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_LoadPNG(
    &self,
    filename: *const c_char,
    bmp: *mut LICE_IBitmap
) -> *mut LICE_IBitmap

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_LoadPNGFromResource(
    &self,
    hInst: HINSTANCE,
    resid: *const c_char,
    bmp: *mut LICE_IBitmap
) -> *mut LICE_IBitmap

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_MeasureText(
    &self,
    string: *const c_char,
    w: *mut c_int,
    h: *mut c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_MultiplyAddRect(
    &self,
    dest: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    w: c_int,
    h: c_int,
    rsc: f32,
    gsc: f32,
    bsc: f32,
    asc: f32,
    radd: f32,
    gadd: f32,
    badd: f32,
    aadd: f32
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_PutPixel(
    &self,
    bm: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    color: c_uint,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_RotatedBlit(
    &self,
    dest: *mut LICE_IBitmap,
    src: *mut LICE_IBitmap,
    dstx: c_int,
    dsty: c_int,
    dstw: c_int,
    dsth: c_int,
    srcx: f32,
    srcy: f32,
    srcw: f32,
    srch: f32,
    angle: f32,
    cliptosourcerect: bool,
    alpha: f32,
    mode: c_int,
    rotxcent: f32,
    rotycent: f32
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_RoundRect(
    &self,
    drawbm: *mut LICE_IBitmap,
    xpos: f32,
    ypos: f32,
    w: f32,
    h: f32,
    cornerradius: c_int,
    col: c_uint,
    alpha: f32,
    mode: c_int,
    aa: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_ScaledBlit(
    &self,
    dest: *mut LICE_IBitmap,
    src: *mut LICE_IBitmap,
    dstx: c_int,
    dsty: c_int,
    dstw: c_int,
    dsth: c_int,
    srcx: f32,
    srcy: f32,
    srcw: f32,
    srch: f32,
    alpha: f32,
    mode: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_SimpleFill(
    &self,
    dest: *mut LICE_IBitmap,
    x: c_int,
    y: c_int,
    newcolor: c_uint,
    comparemask: c_uint,
    keepmask: c_uint
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LICE_ThickFLine(
    &self,
    dest: *mut LICE_IBitmap,
    x1: f64,
    y1: f64,
    x2: f64,
    y2: f64,
    color: c_uint,
    alpha: f32,
    mode: c_int,
    wid: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn LocalizeString(
    &self,
    src_string: *const c_char,
    section: *const c_char,
    flagsOptional: c_int
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Loop_OnArrow(
    &self,
    project: *mut ReaProject,
    direction: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn Main_OnCommand(&self, command: c_int, flag: c_int)

pub unsafe fn Main_OnCommandEx(
    &self,
    command: c_int,
    flag: c_int,
    proj: *mut ReaProject
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Main_openProject(&self, name: *const c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Main_SaveProject(
    &self,
    proj: *mut ReaProject,
    forceSaveAsInOptional: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Main_SaveProjectEx(
    &self,
    proj: *mut ReaProject,
    filename: *const c_char,
    options: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn Main_UpdateLoopInfo(&self, ignoremask: c_int)

pub unsafe fn MarkProjectDirty(&self, proj: *mut ReaProject)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MarkTrackItemsDirty(
    &self,
    track: *mut MediaTrack,
    item: *mut MediaItem
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Master_GetPlayRate(&self, project: *mut ReaProject) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Master_GetPlayRateAtTime(
    &self,
    time_s: f64,
    proj: *mut ReaProject
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub fn Master_GetTempo(&self) -> f64

pub fn Master_NormalizePlayRate(&self, playrate: f64, isnormalized: bool) -> f64

pub fn Master_NormalizeTempo(&self, bpm: f64, isnormalized: bool) -> f64

pub unsafe fn MB(
    &self,
    msg: *const c_char,
    title: *const c_char,
    type_: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MediaItemDescendsFromTrack(
    &self,
    item: *mut MediaItem,
    track: *mut MediaTrack
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_CountEvts(
    &self,
    take: *mut MediaItem_Take,
    notecntOut: *mut c_int,
    ccevtcntOut: *mut c_int,
    textsyxevtcntOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_DeleteCC(
    &self,
    take: *mut MediaItem_Take,
    ccidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_DeleteEvt(
    &self,
    take: *mut MediaItem_Take,
    evtidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_DeleteNote(
    &self,
    take: *mut MediaItem_Take,
    noteidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_DeleteTextSysexEvt(
    &self,
    take: *mut MediaItem_Take,
    textsyxevtidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_DisableSort(&self, take: *mut MediaItem_Take)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_EnumSelCC(
    &self,
    take: *mut MediaItem_Take,
    ccidx: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_EnumSelEvts(
    &self,
    take: *mut MediaItem_Take,
    evtidx: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_EnumSelNotes(
    &self,
    take: *mut MediaItem_Take,
    noteidx: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_EnumSelTextSysexEvts(
    &self,
    take: *mut MediaItem_Take,
    textsyxidx: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn MIDI_eventlist_Create(&self) -> *mut MIDI_eventlist

pub unsafe fn MIDI_eventlist_Destroy(&self, evtlist: *mut MIDI_eventlist)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetAllEvts(
    &self,
    take: *mut MediaItem_Take,
    bufOutNeedBig: *mut c_char,
    bufOutNeedBig_sz: *mut c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetCC(
    &self,
    take: *mut MediaItem_Take,
    ccidx: c_int,
    selectedOut: *mut bool,
    mutedOut: *mut bool,
    ppqposOut: *mut f64,
    chanmsgOut: *mut c_int,
    chanOut: *mut c_int,
    msg2Out: *mut c_int,
    msg3Out: *mut c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetCCShape(
    &self,
    take: *mut MediaItem_Take,
    ccidx: c_int,
    shapeOut: *mut c_int,
    beztensionOut: *mut f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetEvt(
    &self,
    take: *mut MediaItem_Take,
    evtidx: c_int,
    selectedOut: *mut bool,
    mutedOut: *mut bool,
    ppqposOut: *mut f64,
    msgOut: *mut c_char,
    msgOut_sz: *mut c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetGrid(
    &self,
    take: *mut MediaItem_Take,
    swingOutOptional: *mut f64,
    noteLenOutOptional: *mut f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetHash(
    &self,
    take: *mut MediaItem_Take,
    notesonly: bool,
    hashOut: *mut c_char,
    hashOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetNote(
    &self,
    take: *mut MediaItem_Take,
    noteidx: c_int,
    selectedOut: *mut bool,
    mutedOut: *mut bool,
    startppqposOut: *mut f64,
    endppqposOut: *mut f64,
    chanOut: *mut c_int,
    pitchOut: *mut c_int,
    velOut: *mut c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetPPQPos_EndOfMeasure(
    &self,
    take: *mut MediaItem_Take,
    ppqpos: f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetPPQPos_StartOfMeasure(
    &self,
    take: *mut MediaItem_Take,
    ppqpos: f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetPPQPosFromProjQN(
    &self,
    take: *mut MediaItem_Take,
    projqn: f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetPPQPosFromProjTime(
    &self,
    take: *mut MediaItem_Take,
    projtime: f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetProjQNFromPPQPos(
    &self,
    take: *mut MediaItem_Take,
    ppqpos: f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetProjTimeFromPPQPos(
    &self,
    take: *mut MediaItem_Take,
    ppqpos: f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetRecentInputEvent(
    &self,
    idx: c_int,
    bufOut: *mut c_char,
    bufOut_sz: *mut c_int,
    tsOut: *mut c_int,
    devIdxOut: *mut c_int,
    projPosOut: *mut f64,
    projLoopCntOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetScale(
    &self,
    take: *mut MediaItem_Take,
    rootOut: *mut c_int,
    scaleOut: *mut c_int,
    nameOut: *mut c_char,
    nameOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetTextSysexEvt(
    &self,
    take: *mut MediaItem_Take,
    textsyxevtidx: c_int,
    selectedOutOptional: *mut bool,
    mutedOutOptional: *mut bool,
    ppqposOutOptional: *mut f64,
    typeOutOptional: *mut c_int,
    msgOptional: *mut c_char,
    msgOptional_sz: *mut c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_GetTrackHash(
    &self,
    track: *mut MediaTrack,
    notesonly: bool,
    hashOut: *mut c_char,
    hashOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn midi_init(&self, force_reinit_input: c_int, force_reinit_output: c_int)

pub unsafe fn MIDI_InsertCC(
    &self,
    take: *mut MediaItem_Take,
    selected: bool,
    muted: bool,
    ppqpos: f64,
    chanmsg: c_int,
    chan: c_int,
    msg2: c_int,
    msg3: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_InsertEvt(
    &self,
    take: *mut MediaItem_Take,
    selected: bool,
    muted: bool,
    ppqpos: f64,
    bytestr: *const c_char,
    bytestr_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_InsertNote(
    &self,
    take: *mut MediaItem_Take,
    selected: bool,
    muted: bool,
    startppqpos: f64,
    endppqpos: f64,
    chan: c_int,
    pitch: c_int,
    vel: c_int,
    noSortInOptional: *const bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_InsertTextSysexEvt(
    &self,
    take: *mut MediaItem_Take,
    selected: bool,
    muted: bool,
    ppqpos: f64,
    type_: c_int,
    bytestr: *const c_char,
    bytestr_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn midi_reinit(&self)

pub unsafe fn MIDI_SelectAll(&self, take: *mut MediaItem_Take, select: bool)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_SetAllEvts(
    &self,
    take: *mut MediaItem_Take,
    buf: *const c_char,
    buf_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_SetCC(
    &self,
    take: *mut MediaItem_Take,
    ccidx: c_int,
    selectedInOptional: *const bool,
    mutedInOptional: *const bool,
    ppqposInOptional: *const f64,
    chanmsgInOptional: *const c_int,
    chanInOptional: *const c_int,
    msg2InOptional: *const c_int,
    msg3InOptional: *const c_int,
    noSortInOptional: *const bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_SetCCShape(
    &self,
    take: *mut MediaItem_Take,
    ccidx: c_int,
    shape: c_int,
    beztension: f64,
    noSortInOptional: *const bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_SetEvt(
    &self,
    take: *mut MediaItem_Take,
    evtidx: c_int,
    selectedInOptional: *const bool,
    mutedInOptional: *const bool,
    ppqposInOptional: *const f64,
    msgOptional: *const c_char,
    msgOptional_sz: c_int,
    noSortInOptional: *const bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_SetItemExtents(
    &self,
    item: *mut MediaItem,
    startQN: f64,
    endQN: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_SetNote(
    &self,
    take: *mut MediaItem_Take,
    noteidx: c_int,
    selectedInOptional: *const bool,
    mutedInOptional: *const bool,
    startppqposInOptional: *const f64,
    endppqposInOptional: *const f64,
    chanInOptional: *const c_int,
    pitchInOptional: *const c_int,
    velInOptional: *const c_int,
    noSortInOptional: *const bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_SetTextSysexEvt(
    &self,
    take: *mut MediaItem_Take,
    textsyxevtidx: c_int,
    selectedInOptional: *const bool,
    mutedInOptional: *const bool,
    ppqposInOptional: *const f64,
    typeInOptional: *const c_int,
    msgOptional: *const c_char,
    msgOptional_sz: c_int,
    noSortInOptional: *const bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDI_Sort(&self, take: *mut MediaItem_Take)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDIEditor_EnumTakes(
    &self,
    midieditor: HWND,
    takeindex: c_int,
    editable_only: bool
) -> *mut MediaItem_Take

Safety

REAPER can crash if you pass an invalid pointer.

pub fn MIDIEditor_GetActive(&self) -> HWND

pub unsafe fn MIDIEditor_GetMode(&self, midieditor: HWND) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDIEditor_GetSetting_int(
    &self,
    midieditor: HWND,
    setting_desc: *const c_char
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDIEditor_GetSetting_str(
    &self,
    midieditor: HWND,
    setting_desc: *const c_char,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDIEditor_GetTake(&self, midieditor: HWND) -> *mut MediaItem_Take

Safety

REAPER can crash if you pass an invalid pointer.

pub fn MIDIEditor_LastFocused_OnCommand(
    &self,
    command_id: c_int,
    islistviewcommand: bool
) -> bool

pub unsafe fn MIDIEditor_OnCommand(
    &self,
    midieditor: HWND,
    command_id: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn MIDIEditor_SetSetting_int(
    &self,
    midieditor: HWND,
    setting_desc: *const c_char,
    setting: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn mkpanstr(&self, strNeed64: *mut c_char, pan: f64)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn mkvolpanstr(&self, strNeed64: *mut c_char, vol: f64, pan: f64)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn mkvolstr(&self, strNeed64: *mut c_char, vol: f64)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn MoveEditCursor(&self, adjamt: f64, dosel: bool)

pub unsafe fn MoveMediaItemToTrack(
    &self,
    item: *mut MediaItem,
    desttr: *mut MediaTrack
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn MuteAllTracks(&self, mute: bool)

pub unsafe fn my_getViewport(
    &self,
    r: *mut RECT,
    sr: *const RECT,
    wantWorkArea: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn NamedCommandLookup(&self, command_name: *const c_char) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn OnPauseButton(&self)

pub unsafe fn OnPauseButtonEx(&self, proj: *mut ReaProject)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn OnPlayButton(&self)

pub unsafe fn OnPlayButtonEx(&self, proj: *mut ReaProject)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn OnStopButton(&self)

pub unsafe fn OnStopButtonEx(&self, proj: *mut ReaProject)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn OpenColorThemeFile(&self, fn_: *const c_char) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn OpenMediaExplorer(&self, mediafn: *const c_char, play: bool) -> HWND

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn OscLocalMessageToHost(
    &self,
    message: *const c_char,
    valueInOptional: *const f64
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn parse_timestr(&self, buf: *const c_char) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn parse_timestr_len(
    &self,
    buf: *const c_char,
    offset: f64,
    modeoverride: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn parse_timestr_pos(
    &self,
    buf: *const c_char,
    modeoverride: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn parsepanstr(&self, str: *const c_char) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Sink_Create(
    &self,
    filename: *const c_char,
    cfg: *const c_char,
    cfg_sz: c_int,
    nch: c_int,
    srate: c_int,
    buildpeaks: bool
) -> *mut PCM_sink

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Sink_CreateEx(
    &self,
    proj: *mut ReaProject,
    filename: *const c_char,
    cfg: *const c_char,
    cfg_sz: c_int,
    nch: c_int,
    srate: c_int,
    buildpeaks: bool
) -> *mut PCM_sink

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Sink_CreateMIDIFile(
    &self,
    filename: *const c_char,
    cfg: *const c_char,
    cfg_sz: c_int,
    bpm: f64,
    div: c_int
) -> *mut PCM_sink

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Sink_CreateMIDIFileEx(
    &self,
    proj: *mut ReaProject,
    filename: *const c_char,
    cfg: *const c_char,
    cfg_sz: c_int,
    bpm: f64,
    div: c_int
) -> *mut PCM_sink

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Sink_Enum(
    &self,
    idx: c_int,
    descstrOut: *mut *const c_char
) -> c_uint

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Sink_GetExtension(
    &self,
    data: *const c_char,
    data_sz: c_int
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Sink_ShowConfig(
    &self,
    cfg: *const c_char,
    cfg_sz: c_int,
    hwndParent: HWND
) -> HWND

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Source_BuildPeaks(
    &self,
    src: *mut PCM_source,
    mode: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Source_CreateFromFile(
    &self,
    filename: *const c_char
) -> *mut PCM_source

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Source_CreateFromFileEx(
    &self,
    filename: *const c_char,
    forcenoMidiImp: bool
) -> *mut PCM_source

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Source_CreateFromSimple(
    &self,
    dec: *mut ISimpleMediaDecoder,
    fn_: *const c_char
) -> *mut PCM_source

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Source_CreateFromType(
    &self,
    sourcetype: *const c_char
) -> *mut PCM_source

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Source_Destroy(&self, src: *mut PCM_source)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Source_GetPeaks(
    &self,
    src: *mut PCM_source,
    peakrate: f64,
    starttime: f64,
    numchannels: c_int,
    numsamplesperchannel: c_int,
    want_extra_type: c_int,
    buf: *mut f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PCM_Source_GetSectionInfo(
    &self,
    src: *mut PCM_source,
    offsOut: *mut f64,
    lenOut: *mut f64,
    revOut: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PeakBuild_Create(
    &self,
    src: *mut PCM_source,
    fn_: *const c_char,
    srate: c_int,
    nch: c_int
) -> *mut REAPER_PeakBuild_Interface

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PeakBuild_CreateEx(
    &self,
    src: *mut PCM_source,
    fn_: *const c_char,
    srate: c_int,
    nch: c_int,
    flags: c_int
) -> *mut REAPER_PeakBuild_Interface

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PeakGet_Create(
    &self,
    fn_: *const c_char,
    srate: c_int,
    nch: c_int
) -> *mut REAPER_PeakGet_Interface

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PitchShiftSubModeMenu(
    &self,
    hwnd: HWND,
    x: c_int,
    y: c_int,
    mode: c_int,
    submode_sel: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PlayPreview(&self, preview: *mut preview_register_t) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PlayPreviewEx(
    &self,
    preview: *mut preview_register_t,
    bufflags: c_int,
    measure_align: f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PlayTrackPreview(&self, preview: *mut preview_register_t) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PlayTrackPreview2(
    &self,
    proj: *mut ReaProject,
    preview: *mut preview_register_t
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn PlayTrackPreview2Ex(
    &self,
    proj: *mut ReaProject,
    preview: *mut preview_register_t,
    flags: c_int,
    measure_align: f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn plugin_getapi(&self, name: *const c_char) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub fn plugin_getFilterList(&self) -> *const c_char

pub fn plugin_getImportableProjectFilterList(&self) -> *const c_char

pub unsafe fn plugin_register(
    &self,
    name: *const c_char,
    infostruct: *mut c_void
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn PluginWantsAlwaysRunFx(&self, amt: c_int)

pub fn PreventUIRefresh(&self, prevent_count: c_int)

pub unsafe fn projectconfig_var_addr(
    &self,
    proj: *mut ReaProject,
    idx: c_int
) -> *mut c_void

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn projectconfig_var_getoffs(
    &self,
    name: *const c_char,
    szOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn PromptForAction(
    &self,
    session_mode: c_int,
    init_id: c_int,
    section_id: c_int
) -> c_int

pub fn realloc_cmd_clear(&self, tok: c_int)

pub unsafe fn realloc_cmd_ptr(
    &self,
    ptr: *mut *mut c_char,
    ptr_size: *mut c_int,
    new_size: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn realloc_cmd_register_buf(
    &self,
    ptr: *mut *mut c_char,
    ptr_size: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn ReaperGetPitchShiftAPI(&self, version: c_int) -> *mut IReaperPitchShift

pub unsafe fn ReaScriptError(&self, errmsg: *const c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn RecursiveCreateDirectory(
    &self,
    path: *const c_char,
    ignored: usize
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn reduce_open_files(&self, flags: c_int) -> c_int

pub fn RefreshToolbar(&self, command_id: c_int)

pub fn RefreshToolbar2(&self, section_id: c_int, command_id: c_int)

pub unsafe fn relative_fn(
    &self,
    in_: *const c_char,
    out: *mut c_char,
    out_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn RemoveTrackSend(
    &self,
    tr: *mut MediaTrack,
    category: c_int,
    sendidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn RenderFileSection(
    &self,
    source_filename: *const c_char,
    target_filename: *const c_char,
    start_percent: f64,
    end_percent: f64,
    playrate: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn ReorderSelectedTracks(
    &self,
    beforeTrackIdx: c_int,
    makePrevFolder: c_int
) -> bool

pub fn Resample_EnumModes(&self, mode: c_int) -> *const c_char

pub fn Resampler_Create(&self) -> *mut REAPER_Resample_Interface

pub unsafe fn resolve_fn(
    &self,
    in_: *const c_char,
    out: *mut c_char,
    out_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn resolve_fn2(
    &self,
    in_: *const c_char,
    out: *mut c_char,
    out_sz: c_int,
    checkSubDirOptional: *const c_char
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ResolveRenderPattern(
    &self,
    project: *mut ReaProject,
    path: *const c_char,
    pattern: *const c_char,
    targets: *mut c_char,
    targets_sz: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn ReverseNamedCommandLookup(&self, command_id: c_int) -> *const c_char

pub fn ScaleFromEnvelopeMode(&self, scaling_mode: c_int, val: f64) -> f64

pub fn ScaleToEnvelopeMode(&self, scaling_mode: c_int, val: f64) -> f64

pub unsafe fn screenset_register(
    &self,
    id: *mut c_char,
    callbackFunc: *mut c_void,
    param: *mut c_void
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn screenset_registerNew(
    &self,
    id: *mut c_char,
    callbackFunc: Option<unsafe extern "C" fn(action: c_int, id: *const c_char, param: *mut c_void, actionParm: *mut c_void, actionParmSize: c_int) -> LRESULT>,
    param: *mut c_void
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn screenset_unregister(&self, id: *mut c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn screenset_unregisterByParam(&self, param: *mut c_void)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn screenset_updateLastFocus(&self, prevWin: HWND)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn SectionFromUniqueID(&self, uniqueID: c_int) -> *mut KbdSectionInfo

pub unsafe fn SelectAllMediaItems(&self, proj: *mut ReaProject, selected: bool)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SelectProjectInstance(&self, proj: *mut ReaProject)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SendLocalOscMessage(
    &self,
    local_osc_handler: *mut c_void,
    msg: *const c_char,
    msglen: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetActiveTake(&self, take: *mut MediaItem_Take)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn SetAutomationMode(&self, mode: c_int, onlySel: bool)

pub unsafe fn SetCurrentBPM(
    &self,
    __proj: *mut ReaProject,
    bpm: f64,
    wantUndo: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetCursorContext(
    &self,
    mode: c_int,
    envInOptional: *mut TrackEnvelope
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn SetEditCurPos(&self, time: f64, moveview: bool, seekplay: bool)

pub unsafe fn SetEditCurPos2(
    &self,
    proj: *mut ReaProject,
    time: f64,
    moveview: bool,
    seekplay: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetEnvelopePoint(
    &self,
    envelope: *mut TrackEnvelope,
    ptidx: c_int,
    timeInOptional: *mut f64,
    valueInOptional: *mut f64,
    shapeInOptional: *mut c_int,
    tensionInOptional: *mut f64,
    selectedInOptional: *mut bool,
    noSortInOptional: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetEnvelopePointEx(
    &self,
    envelope: *mut TrackEnvelope,
    autoitem_idx: c_int,
    ptidx: c_int,
    timeInOptional: *mut f64,
    valueInOptional: *mut f64,
    shapeInOptional: *mut c_int,
    tensionInOptional: *mut f64,
    selectedInOptional: *mut bool,
    noSortInOptional: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetEnvelopeStateChunk(
    &self,
    env: *mut TrackEnvelope,
    str: *const c_char,
    isundoOptional: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetExtState(
    &self,
    section: *const c_char,
    key: *const c_char,
    value: *const c_char,
    persist: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn SetGlobalAutomationOverride(&self, mode: c_int)

pub unsafe fn SetItemStateChunk(
    &self,
    item: *mut MediaItem,
    str: *const c_char,
    isundoOptional: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn SetMasterTrackVisibility(&self, flag: c_int) -> c_int

pub unsafe fn SetMediaItemInfo_Value(
    &self,
    item: *mut MediaItem,
    parmname: *const c_char,
    newvalue: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetMediaItemLength(
    &self,
    item: *mut MediaItem,
    length: f64,
    refreshUI: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetMediaItemPosition(
    &self,
    item: *mut MediaItem,
    position: f64,
    refreshUI: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetMediaItemSelected(&self, item: *mut MediaItem, selected: bool)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetMediaItemTake_Source(
    &self,
    take: *mut MediaItem_Take,
    source: *mut PCM_source
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetMediaItemTakeInfo_Value(
    &self,
    take: *mut MediaItem_Take,
    parmname: *const c_char,
    newvalue: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetMediaTrackInfo_Value(
    &self,
    tr: *mut MediaTrack,
    parmname: *const c_char,
    newvalue: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetMIDIEditorGrid(&self, project: *mut ReaProject, division: f64)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetMixerScroll(
    &self,
    leftmosttrack: *mut MediaTrack
) -> *mut MediaTrack

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetMouseModifier(
    &self,
    context: *const c_char,
    modifier_flag: c_int,
    action: *const c_char
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetOnlyTrackSelected(&self, track: *mut MediaTrack)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetProjectGrid(&self, project: *mut ReaProject, division: f64)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetProjectMarker(
    &self,
    markrgnindexnumber: c_int,
    isrgn: bool,
    pos: f64,
    rgnend: f64,
    name: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetProjectMarker2(
    &self,
    proj: *mut ReaProject,
    markrgnindexnumber: c_int,
    isrgn: bool,
    pos: f64,
    rgnend: f64,
    name: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetProjectMarker3(
    &self,
    proj: *mut ReaProject,
    markrgnindexnumber: c_int,
    isrgn: bool,
    pos: f64,
    rgnend: f64,
    name: *const c_char,
    color: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetProjectMarker4(
    &self,
    proj: *mut ReaProject,
    markrgnindexnumber: c_int,
    isrgn: bool,
    pos: f64,
    rgnend: f64,
    name: *const c_char,
    color: c_int,
    flags: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetProjectMarkerByIndex(
    &self,
    proj: *mut ReaProject,
    markrgnidx: c_int,
    isrgn: bool,
    pos: f64,
    rgnend: f64,
    IDnumber: c_int,
    name: *const c_char,
    color: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetProjectMarkerByIndex2(
    &self,
    proj: *mut ReaProject,
    markrgnidx: c_int,
    isrgn: bool,
    pos: f64,
    rgnend: f64,
    IDnumber: c_int,
    name: *const c_char,
    color: c_int,
    flags: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetProjExtState(
    &self,
    proj: *mut ReaProject,
    extname: *const c_char,
    key: *const c_char,
    value: *const c_char
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetRegionRenderMatrix(
    &self,
    proj: *mut ReaProject,
    regionindex: c_int,
    track: *mut MediaTrack,
    flag: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetRenderLastError(&self, errorstr: *const c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTakeMarker(
    &self,
    take: *mut MediaItem_Take,
    idx: c_int,
    nameIn: *const c_char,
    srcposInOptional: *mut f64,
    colorInOptional: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTakeStretchMarker(
    &self,
    take: *mut MediaItem_Take,
    idx: c_int,
    pos: f64,
    srcposInOptional: *const f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTakeStretchMarkerSlope(
    &self,
    take: *mut MediaItem_Take,
    idx: c_int,
    slope: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTempoTimeSigMarker(
    &self,
    proj: *mut ReaProject,
    ptidx: c_int,
    timepos: f64,
    measurepos: c_int,
    beatpos: f64,
    bpm: f64,
    timesig_num: c_int,
    timesig_denom: c_int,
    lineartempo: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetThemeColor(
    &self,
    ini_key: *const c_char,
    color: c_int,
    flagsOptional: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn SetToggleCommandState(
    &self,
    section_id: c_int,
    command_id: c_int,
    state: c_int
) -> bool

pub unsafe fn SetTrackAutomationMode(&self, tr: *mut MediaTrack, mode: c_int)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackColor(&self, track: *mut MediaTrack, color: c_int)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackMIDILyrics(
    &self,
    track: *mut MediaTrack,
    flag: c_int,
    str: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackMIDINoteName(
    &self,
    track: c_int,
    pitch: c_int,
    chan: c_int,
    name: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackMIDINoteNameEx(
    &self,
    proj: *mut ReaProject,
    track: *mut MediaTrack,
    pitch: c_int,
    chan: c_int,
    name: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackSelected(&self, track: *mut MediaTrack, selected: bool)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackSendInfo_Value(
    &self,
    tr: *mut MediaTrack,
    category: c_int,
    sendidx: c_int,
    parmname: *const c_char,
    newvalue: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackSendUIPan(
    &self,
    track: *mut MediaTrack,
    send_idx: c_int,
    pan: f64,
    isend: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackSendUIVol(
    &self,
    track: *mut MediaTrack,
    send_idx: c_int,
    vol: f64,
    isend: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackStateChunk(
    &self,
    track: *mut MediaTrack,
    str: *const c_char,
    isundoOptional: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackUIInputMonitor(
    &self,
    track: *mut MediaTrack,
    monitor: c_int,
    igngroupflags: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackUIMute(
    &self,
    track: *mut MediaTrack,
    mute: c_int,
    igngroupflags: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackUIPan(
    &self,
    track: *mut MediaTrack,
    pan: f64,
    relative: bool,
    done: bool,
    igngroupflags: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackUIPolarity(
    &self,
    track: *mut MediaTrack,
    polarity: c_int,
    igngroupflags: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackUIRecArm(
    &self,
    track: *mut MediaTrack,
    recarm: c_int,
    igngroupflags: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackUISolo(
    &self,
    track: *mut MediaTrack,
    solo: c_int,
    igngroupflags: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackUIVolume(
    &self,
    track: *mut MediaTrack,
    volume: f64,
    relative: bool,
    done: bool,
    igngroupflags: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn SetTrackUIWidth(
    &self,
    track: *mut MediaTrack,
    width: f64,
    relative: bool,
    done: bool,
    igngroupflags: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ShowActionList(&self, caller: *mut KbdSectionInfo, callerWnd: HWND)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ShowConsoleMsg(&self, msg: *const c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ShowMessageBox(
    &self,
    msg: *const c_char,
    title: *const c_char,
    type_: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ShowPopupMenu(
    &self,
    name: *const c_char,
    x: c_int,
    y: c_int,
    hwndParentOptional: HWND,
    ctxOptional: *mut c_void,
    ctx2Optional: c_int,
    ctx3Optional: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn SLIDER2DB(&self, y: f64) -> f64

pub unsafe fn SnapToGrid(&self, project: *mut ReaProject, time_pos: f64) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub fn SoloAllTracks(&self, solo: c_int)

pub fn Splash_GetWnd(&self) -> HWND

pub unsafe fn SplitMediaItem(
    &self,
    item: *mut MediaItem,
    position: f64
) -> *mut MediaItem

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn StopPreview(&self, preview: *mut preview_register_t) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn StopTrackPreview(&self, preview: *mut preview_register_t) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn StopTrackPreview2(
    &self,
    proj: *mut ReaProject,
    preview: *mut preview_register_t
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn stringToGuid(&self, str: *const c_char, g: *mut GUID)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn StuffMIDIMessage(&self, mode: c_int, msg1: c_int, msg2: c_int, msg3: c_int)

pub unsafe fn TakeFX_AddByName(
    &self,
    take: *mut MediaItem_Take,
    fxname: *const c_char,
    instantiate: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_CopyToTake(
    &self,
    src_take: *mut MediaItem_Take,
    src_fx: c_int,
    dest_take: *mut MediaItem_Take,
    dest_fx: c_int,
    is_move: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_CopyToTrack(
    &self,
    src_take: *mut MediaItem_Take,
    src_fx: c_int,
    dest_track: *mut MediaTrack,
    dest_fx: c_int,
    is_move: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_Delete(&self, take: *mut MediaItem_Take, fx: c_int) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_EndParamEdit(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_FormatParamValue(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    val: f64,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_FormatParamValueNormalized(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    value: f64,
    buf: *mut c_char,
    buf_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetChainVisible(&self, take: *mut MediaItem_Take) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetCount(&self, take: *mut MediaItem_Take) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetEnabled(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetEnvelope(
    &self,
    take: *mut MediaItem_Take,
    fxindex: c_int,
    parameterindex: c_int,
    create: bool
) -> *mut TrackEnvelope

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetFloatingWindow(
    &self,
    take: *mut MediaItem_Take,
    index: c_int
) -> HWND

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetFormattedParamValue(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetFXGUID(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int
) -> *mut GUID

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetFXName(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetIOSize(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    inputPinsOut: *mut c_int,
    outputPinsOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetNamedConfigParm(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    parmname: *const c_char,
    bufOutNeedBig: *mut c_char,
    bufOutNeedBig_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetNumParams(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetOffline(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetOpen(&self, take: *mut MediaItem_Take, fx: c_int) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetParam(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    minvalOut: *mut f64,
    maxvalOut: *mut f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetParameterStepSizes(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    stepOut: *mut f64,
    smallstepOut: *mut f64,
    largestepOut: *mut f64,
    istoggleOut: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetParamEx(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    minvalOut: *mut f64,
    maxvalOut: *mut f64,
    midvalOut: *mut f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetParamFromIdent(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    ident_str: *const c_char
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetParamIdent(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetParamName(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetParamNormalized(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetPinMappings(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    isoutput: c_int,
    pin: c_int,
    high32Out: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetPreset(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    presetnameOut: *mut c_char,
    presetnameOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetPresetIndex(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    numberOfPresetsOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_GetUserPresetFilename(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    fnOut: *mut c_char,
    fnOut_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_NavigatePresets(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    presetmove: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_SetEnabled(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    enabled: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_SetNamedConfigParm(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    parmname: *const c_char,
    value: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_SetOffline(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    offline: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_SetOpen(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    open: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_SetParam(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    val: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_SetParamNormalized(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    param: c_int,
    value: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_SetPinMappings(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    isoutput: c_int,
    pin: c_int,
    low32bits: c_int,
    hi32bits: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_SetPreset(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    presetname: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_SetPresetByIndex(
    &self,
    take: *mut MediaItem_Take,
    fx: c_int,
    idx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeFX_Show(
    &self,
    take: *mut MediaItem_Take,
    index: c_int,
    showFlag: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TakeIsMIDI(&self, take: *mut MediaItem_Take) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ThemeLayout_GetLayout(
    &self,
    section: *const c_char,
    idx: c_int,
    nameOut: *mut c_char,
    nameOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ThemeLayout_GetParameter(
    &self,
    wp: c_int,
    descOutOptional: *mut *const c_char,
    valueOutOptional: *mut c_int,
    defValueOutOptional: *mut c_int,
    minValueOutOptional: *mut c_int,
    maxValueOutOptional: *mut c_int
) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub fn ThemeLayout_RefreshAll(&self)

pub unsafe fn ThemeLayout_SetLayout(
    &self,
    section: *const c_char,
    layout: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn ThemeLayout_SetParameter(
    &self,
    wp: c_int,
    value: c_int,
    persist: bool
) -> bool

pub fn time_precise(&self) -> f64

pub unsafe fn TimeMap2_beatsToTime(
    &self,
    proj: *mut ReaProject,
    tpos: f64,
    measuresInOptional: *const c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TimeMap2_GetDividedBpmAtTime(
    &self,
    proj: *mut ReaProject,
    time: f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TimeMap2_GetNextChangeTime(
    &self,
    proj: *mut ReaProject,
    time: f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TimeMap2_QNToTime(&self, proj: *mut ReaProject, qn: f64) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TimeMap2_timeToBeats(
    &self,
    proj: *mut ReaProject,
    tpos: f64,
    measuresOutOptional: *mut c_int,
    cmlOutOptional: *mut c_int,
    fullbeatsOutOptional: *mut f64,
    cdenomOutOptional: *mut c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TimeMap2_timeToQN(&self, proj: *mut ReaProject, tpos: f64) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TimeMap_curFrameRate(
    &self,
    proj: *mut ReaProject,
    dropFrameOut: *mut bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub fn TimeMap_GetDividedBpmAtTime(&self, time: f64) -> f64

pub unsafe fn TimeMap_GetMeasureInfo(
    &self,
    proj: *mut ReaProject,
    measure: c_int,
    qn_startOut: *mut f64,
    qn_endOut: *mut f64,
    timesig_numOut: *mut c_int,
    timesig_denomOut: *mut c_int,
    tempoOut: *mut f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TimeMap_GetMetronomePattern(
    &self,
    proj: *mut ReaProject,
    time: f64,
    pattern: *mut c_char,
    pattern_sz: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TimeMap_GetTimeSigAtTime(
    &self,
    proj: *mut ReaProject,
    time: f64,
    timesig_numOut: *mut c_int,
    timesig_denomOut: *mut c_int,
    tempoOut: *mut f64
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TimeMap_QNToMeasures(
    &self,
    proj: *mut ReaProject,
    qn: f64,
    qnMeasureStartOutOptional: *mut f64,
    qnMeasureEndOutOptional: *mut f64
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub fn TimeMap_QNToTime(&self, qn: f64) -> f64

pub unsafe fn TimeMap_QNToTime_abs(&self, proj: *mut ReaProject, qn: f64) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub fn TimeMap_timeToQN(&self, tpos: f64) -> f64

pub unsafe fn TimeMap_timeToQN_abs(&self, proj: *mut ReaProject, tpos: f64) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ToggleTrackSendUIMute(
    &self,
    track: *mut MediaTrack,
    send_idx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Track_GetPeakHoldDB(
    &self,
    track: *mut MediaTrack,
    channel: c_int,
    clear: bool
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Track_GetPeakInfo(
    &self,
    track: *mut MediaTrack,
    channel: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackCtl_SetToolTip(
    &self,
    fmt: *const c_char,
    xpos: c_int,
    ypos: c_int,
    topmost: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_AddByName(
    &self,
    track: *mut MediaTrack,
    fxname: *const c_char,
    recFX: bool,
    instantiate: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_CopyToTake(
    &self,
    src_track: *mut MediaTrack,
    src_fx: c_int,
    dest_take: *mut MediaItem_Take,
    dest_fx: c_int,
    is_move: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_CopyToTrack(
    &self,
    src_track: *mut MediaTrack,
    src_fx: c_int,
    dest_track: *mut MediaTrack,
    dest_fx: c_int,
    is_move: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_Delete(&self, track: *mut MediaTrack, fx: c_int) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_EndParamEdit(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_FormatParamValue(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    val: f64,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_FormatParamValueNormalized(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    value: f64,
    buf: *mut c_char,
    buf_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetByName(
    &self,
    track: *mut MediaTrack,
    fxname: *const c_char,
    instantiate: bool
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetChainVisible(&self, track: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetCount(&self, track: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetEnabled(&self, track: *mut MediaTrack, fx: c_int) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetEQ(
    &self,
    track: *mut MediaTrack,
    instantiate: bool
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetEQBandEnabled(
    &self,
    track: *mut MediaTrack,
    fxidx: c_int,
    bandtype: c_int,
    bandidx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetEQParam(
    &self,
    track: *mut MediaTrack,
    fxidx: c_int,
    paramidx: c_int,
    bandtypeOut: *mut c_int,
    bandidxOut: *mut c_int,
    paramtypeOut: *mut c_int,
    normvalOut: *mut f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetFloatingWindow(
    &self,
    track: *mut MediaTrack,
    index: c_int
) -> HWND

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetFormattedParamValue(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetFXGUID(
    &self,
    track: *mut MediaTrack,
    fx: c_int
) -> *mut GUID

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetFXName(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetInstrument(&self, track: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetIOSize(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    inputPinsOut: *mut c_int,
    outputPinsOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetNamedConfigParm(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    parmname: *const c_char,
    bufOutNeedBig: *mut c_char,
    bufOutNeedBig_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetNumParams(
    &self,
    track: *mut MediaTrack,
    fx: c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetOffline(&self, track: *mut MediaTrack, fx: c_int) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetOpen(&self, track: *mut MediaTrack, fx: c_int) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetParam(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    minvalOut: *mut f64,
    maxvalOut: *mut f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetParameterStepSizes(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    stepOut: *mut f64,
    smallstepOut: *mut f64,
    largestepOut: *mut f64,
    istoggleOut: *mut bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetParamEx(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    minvalOut: *mut f64,
    maxvalOut: *mut f64,
    midvalOut: *mut f64
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetParamFromIdent(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    ident_str: *const c_char
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetParamIdent(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetParamName(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    bufOut: *mut c_char,
    bufOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetParamNormalized(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int
) -> f64

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetPinMappings(
    &self,
    tr: *mut MediaTrack,
    fx: c_int,
    isoutput: c_int,
    pin: c_int,
    high32Out: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetPreset(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    presetnameOut: *mut c_char,
    presetnameOut_sz: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetPresetIndex(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    numberOfPresetsOut: *mut c_int
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetRecChainVisible(&self, track: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetRecCount(&self, track: *mut MediaTrack) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_GetUserPresetFilename(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    fnOut: *mut c_char,
    fnOut_sz: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_NavigatePresets(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    presetmove: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetEnabled(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    enabled: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetEQBandEnabled(
    &self,
    track: *mut MediaTrack,
    fxidx: c_int,
    bandtype: c_int,
    bandidx: c_int,
    enable: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetEQParam(
    &self,
    track: *mut MediaTrack,
    fxidx: c_int,
    bandtype: c_int,
    bandidx: c_int,
    paramtype: c_int,
    val: f64,
    isnorm: bool
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetNamedConfigParm(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    parmname: *const c_char,
    value: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetOffline(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    offline: bool
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetOpen(&self, track: *mut MediaTrack, fx: c_int, open: bool)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetParam(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    val: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetParamNormalized(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    param: c_int,
    value: f64
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetPinMappings(
    &self,
    tr: *mut MediaTrack,
    fx: c_int,
    isoutput: c_int,
    pin: c_int,
    low32bits: c_int,
    hi32bits: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetPreset(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    presetname: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_SetPresetByIndex(
    &self,
    track: *mut MediaTrack,
    fx: c_int,
    idx: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn TrackFX_Show(
    &self,
    track: *mut MediaTrack,
    index: c_int,
    showFlag: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn TrackList_AdjustWindows(&self, isMinor: bool)

pub fn TrackList_UpdateAllExternalSurfaces(&self)

pub fn Undo_BeginBlock(&self)

pub unsafe fn Undo_BeginBlock2(&self, proj: *mut ReaProject)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_CanRedo2(&self, proj: *mut ReaProject) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_CanUndo2(&self, proj: *mut ReaProject) -> *const c_char

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_DoRedo2(&self, proj: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_DoUndo2(&self, proj: *mut ReaProject) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_EndBlock(&self, descchange: *const c_char, extraflags: c_int)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_EndBlock2(
    &self,
    proj: *mut ReaProject,
    descchange: *const c_char,
    extraflags: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_OnStateChange(&self, descchange: *const c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_OnStateChange2(
    &self,
    proj: *mut ReaProject,
    descchange: *const c_char
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_OnStateChange_Item(
    &self,
    proj: *mut ReaProject,
    name: *const c_char,
    item: *mut MediaItem
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_OnStateChangeEx(
    &self,
    descchange: *const c_char,
    whichStates: c_int,
    trackparm: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn Undo_OnStateChangeEx2(
    &self,
    proj: *mut ReaProject,
    descchange: *const c_char,
    whichStates: c_int,
    trackparm: c_int
)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn update_disk_counters(&self, readamt: c_int, writeamt: c_int)

pub fn UpdateArrange(&self)

pub unsafe fn UpdateItemInProject(&self, item: *mut MediaItem)

Safety

REAPER can crash if you pass an invalid pointer.

pub fn UpdateTimeline(&self)

pub unsafe fn ValidatePtr(
    &self,
    pointer: *mut c_void,
    ctypename: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ValidatePtr2(
    &self,
    proj: *mut ReaProject,
    pointer: *mut c_void,
    ctypename: *const c_char
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn ViewPrefs(&self, page: c_int, pageByName: *const c_char)

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn WDL_VirtualWnd_ScaledBlitBG(
    &self,
    dest: *mut LICE_IBitmap,
    src: *mut WDL_VirtualWnd_BGCfg,
    destx: c_int,
    desty: c_int,
    destw: c_int,
    desth: c_int,
    clipx: c_int,
    clipy: c_int,
    clipw: c_int,
    cliph: c_int,
    alpha: f32,
    mode: c_int
) -> bool

Safety

REAPER can crash if you pass an invalid pointer.

pub fn GetMidiInput(&self, idx: c_int) -> *mut midi_Input

pub fn GetMidiOutput(&self, idx: c_int) -> *mut midi_Output

pub unsafe fn InitializeCoolSB(&self, hwnd: HWND) -> c_schar

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn UninitializeCoolSB(&self, hwnd: HWND) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CoolSB_SetMinThumbSize(
    &self,
    hwnd: HWND,
    wBar: UINT,
    size: UINT
) -> c_schar

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CoolSB_GetScrollInfo(
    &self,
    hwnd: HWND,
    fnBar: c_int,
    lpsi: *mut SCROLLINFO
) -> c_schar

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CoolSB_SetScrollInfo(
    &self,
    hwnd: HWND,
    fnBar: c_int,
    lpsi: *mut SCROLLINFO,
    fRedraw: c_schar
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CoolSB_SetScrollPos(
    &self,
    hwnd: HWND,
    nBar: c_int,
    nPos: c_int,
    fRedraw: c_schar
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CoolSB_SetScrollRange(
    &self,
    hwnd: HWND,
    nBar: c_int,
    nMinPos: c_int,
    nMaxPos: c_int,
    fRedraw: c_schar
) -> c_int

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CoolSB_ShowScrollBar(
    &self,
    hwnd: HWND,
    wBar: c_int,
    fShow: c_schar
) -> c_schar

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CoolSB_SetResizingThumb(
    &self,
    hwnd: HWND,
    active: c_schar
) -> c_schar

Safety

REAPER can crash if you pass an invalid pointer.

pub unsafe fn CoolSB_SetThemeIndex(&self, hwnd: HWND, idx: c_int) -> c_schar

Safety

REAPER can crash if you pass an invalid pointer.

impl Reaper

pub fn make_available_globally(functions: Reaper)

Makes the given instance available globally.

After this has been called, the instance can be queried globally using get().

This can be called once only. Subsequent calls won’t have any effect!

pub fn get() -> &'static Reaper

Gives access to the instance which you made available globally before.

Panics

This panics if make_available_globally() has not been called before.

pub fn pointers(&self) -> &ReaperFunctionPointers

Gives access to the REAPER function pointers.

pub fn plugin_context(&self) -> &PluginContext

Returns the plug-in context.

Trait Implementations

impl Clone for Reaper

fn clone(&self) -> Reaper

Returns a copy of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Reaper

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

Formats the value using the given formatter.

impl Default for Reaper

fn default() -> Reaper

Returns the “default value” for a type.

impl Copy for Reaper