Struct 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().

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(context: &ReaperPluginContext) -> 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, )

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

pub fn AddExtensionsMainMenu(&self) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn BypassFxAllTracks(&self, bypass: c_int)

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

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

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, )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn CSurf_FlushUndo(&self, force: bool)

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

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

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

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

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

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

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

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

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

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

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

pub fn CSurf_OnRecord(&self)

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

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

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

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

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

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

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

pub fn CSurf_OnStop(&self)

pub fn CSurf_OnTempoChange(&self, bpm: f64)

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

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

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

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

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

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, )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn DockWindowActivate(&self, hwnd: HWND)

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

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

pub fn DockWindowRefresh(&self)

pub fn DockWindowRefreshForHWND(&self, hwnd: HWND)

pub fn DockWindowRemove(&self, hwnd: HWND)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub unsafe fn Envelope_Evaluate( &self, envelope: *mut TrackEnvelope, time: f64, samplerate: f64, samplesRequested: c_int, valueOutOptional: *mut f64, dVdSOutOptional: *mut f64, ddVdSOutOptional: *mut f64, dddVdSOutOptional: *mut f64, ) -> c_int

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn GetContextMenu(&self, idx: c_int) -> *mut 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

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

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

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

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

pub unsafe fn GetEnvelopePoint( &self, envelope: *mut TrackEnvelope, ptidx: c_int, timeOutOptional: *mut f64, valueOutOptional: *mut f64, shapeOutOptional: *mut c_int, tensionOutOptional: *mut f64, selectedOutOptional: *mut bool, ) -> bool

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

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

pub unsafe fn GetEnvelopePointEx( &self, envelope: *mut TrackEnvelope, autoitem_idx: c_int, ptidx: c_int, timeOutOptional: *mut f64, valueOutOptional: *mut f64, shapeOutOptional: *mut c_int, tensionOutOptional: *mut f64, selectedOutOptional: *mut bool, ) -> bool

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

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

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

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

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

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

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

pub fn GetGlobalAutomationOverride(&self) -> c_int

pub fn GetHZoomLevel(&self) -> f64

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

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

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

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

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

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

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

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

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

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, )

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

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

pub fn GetMasterTrackVisibility(&self) -> c_int

pub fn GetMaxMidiInputs(&self) -> c_int

pub fn GetMaxMidiOutputs(&self) -> c_int

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 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

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

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

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

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

pub fn GetPlayPosition(&self) -> f64

pub fn GetPlayPosition2(&self) -> f64

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

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

pub fn GetPlayState(&self) -> c_int

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

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

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

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

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

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

pub unsafe fn GetProjectPath(&self, buf: *mut c_char, buf_sz: c_int)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn GetTooltipWindow(&self) -> HWND

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub unsafe fn GetUnderrunTime( &self, audio_xrunOutOptional: *mut c_uint, media_xrunOutOptional: *mut c_uint, curtimeOutOptional: *mut c_uint, )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn IsREAPER(&self) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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: c_uint, ) -> c_int

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

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

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

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

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

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

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

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

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

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

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

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, )

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, )

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, )

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, )

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, )

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

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, )

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

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

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, )

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, )

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, )

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, )

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, )

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, )

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, )

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, )

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, )

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, )

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, )

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

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, )

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, )

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, )

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

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

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

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, )

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

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, )

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, )

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, )

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, )

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

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, )

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

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

pub fn Main_UpdateLoopInfo(&self, ignoremask: c_int)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn midi_reinit(&self)

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

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

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

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

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

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

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

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

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

pub fn MIDIEditor_GetActive(&self) -> HWND

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

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

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

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

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

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

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

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

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

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

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

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

pub fn MuteAllTracks(&self, mute: bool)

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

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

pub fn OnPauseButton(&self)

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

pub fn OnPlayButton(&self)

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

pub fn OnStopButton(&self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, )

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

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

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, )

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

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, )

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) -> isize>, param: *mut c_void, )

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

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

pub fn screenset_updateLastFocus(&self, prevWin: HWND)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn SetGlobalAutomationOverride(&self, mode: c_int)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

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, )

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

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

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

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

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

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

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

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

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, )

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, )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn ThemeLayout_RefreshAll(&self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, )

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, )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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

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

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

pub fn UpdateArrange(&self)

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

pub fn UpdateTimeline(&self)

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

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

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

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

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

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

impl Reaper

pub fn pointers(&self) -> &ReaperFunctionPointers

Gives access to the REAPER function pointers.

Trait Implementations

impl Clone for Reaper

fn clone(&self) -> Reaper

Returns a duplicate of the value.

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