ReaScript API — Documentation

Searchable and easy-to-read list of REAPER ReaScript API functions with common extensions support.
Generated from reascript.html file by X-Raym.
More infos about it on Cockos forum: Documentation: Reascripthelp with Styles and Filtering Tables.

Thank you for considering making a donation to support this free work! ❤️

Functions Definitions

MediaItem* AddMediaItemToTrack(MediaTrack* tr)
MediaItem AddMediaItemToTrack(MediaTrack tr)
MediaItem reaper.AddMediaItemToTrack(MediaTrack tr)
MediaItem RPR_AddMediaItemToTrack(MediaTrack tr)

creates a new media item.

int AddProjectMarker(ReaProject* proj, bool isrgn, double pos, double rgnend, const char* name, int wantidx)
int AddProjectMarker(ReaProject proj, bool isrgn, pos, rgnend, "name", int wantidx)
integer reaper.AddProjectMarker(ReaProject proj, boolean isrgn, number pos, number rgnend, string name, integer wantidx)
Int RPR_AddProjectMarker(ReaProject proj, Boolean isrgn, Float pos, Float rgnend, String name, Int wantidx)

Returns the index of the created marker/region, or -1 on failure. Supply wantidx>=0 if you want a particular index number, but you'll get a different index number a region and wantidx is already in use.

int AddProjectMarker2(ReaProject* proj, bool isrgn, double pos, double rgnend, const char* name, int wantidx, int color)
int AddProjectMarker2(ReaProject proj, bool isrgn, pos, rgnend, "name", int wantidx, int color)
integer reaper.AddProjectMarker2(ReaProject proj, boolean isrgn, number pos, number rgnend, string name, integer wantidx, integer color)
Int RPR_AddProjectMarker2(ReaProject proj, Boolean isrgn, Float pos, Float rgnend, String name, Int wantidx, Int color)

Returns the index of the created marker/region, or -1 on failure. Supply wantidx>=0 if you want a particular index number, but you'll get a different index number a region and wantidx is already in use. color should be 0 (default color), or ColorToNative(r,g,b)|0x1000000

int AddRemoveReaScript(bool add, int sectionID, const char* scriptfn, bool commit)
int AddRemoveReaScript(bool add, int sectionID, "scriptfn", bool commit)
integer reaper.AddRemoveReaScript(boolean add, integer sectionID, string scriptfn, boolean commit)
Int RPR_AddRemoveReaScript(Boolean add, Int sectionID, String scriptfn, Boolean commit)

Add a ReaScript (return the new command ID, or 0 if failed) or remove a ReaScript (return >0 on success). Use commit==true when adding/removing a single script. When bulk adding/removing n scripts, you can optimize the n-1 first calls with commit==false and commit==true for the last call.

MediaItem_Take* AddTakeToMediaItem(MediaItem* item)
MediaItem_Take AddTakeToMediaItem(MediaItem item)
MediaItem_Take reaper.AddTakeToMediaItem(MediaItem item)
MediaItem_Take RPR_AddTakeToMediaItem(MediaItem item)

creates a new take in an item

bool AddTempoTimeSigMarker(ReaProject* proj, double timepos, double bpm, int timesig_num, int timesig_denom, bool lineartempochange)
bool AddTempoTimeSigMarker(ReaProject proj, timepos, bpm, int timesig_num, int timesig_denom, bool lineartempochange)
boolean reaper.AddTempoTimeSigMarker(ReaProject proj, number timepos, number bpm, integer timesig_num, integer timesig_denom, boolean lineartempochange)
Boolean RPR_AddTempoTimeSigMarker(ReaProject proj, Float timepos, Float bpm, Int timesig_num, Int timesig_denom, Boolean lineartempochange)

Deprecated. Use SetTempoTimeSigMarker with ptidx=-1.

void adjustZoom(double amt, int forceset, bool doupd, int centermode)
adjustZoom(amt, int forceset, bool doupd, int centermode)
reaper.adjustZoom(number amt, integer forceset, boolean doupd, integer centermode)
RPR_adjustZoom(Float amt, Int forceset, Boolean doupd, Int centermode)

forceset=0,doupd=true,centermode=-1 for default

bool AnyTrackSolo(ReaProject* proj)
bool AnyTrackSolo(ReaProject proj)
boolean reaper.AnyTrackSolo(ReaProject proj)
Boolean RPR_AnyTrackSolo(ReaProject proj)
bool APIExists(const char* function_name)
bool APIExists("function_name")
boolean reaper.APIExists(string function_name)
Boolean RPR_APIExists(String function_name)

Returns true if function_name exists in the REAPER API

void APITest()
APITest()
reaper.APITest()
RPR_APITest()

Displays a message window if the API was successfully called.

bool ApplyNudge(ReaProject* project, int nudgeflag, int nudgewhat, int nudgeunits, double value, bool reverse, int copies)
bool ApplyNudge(ReaProject project, int nudgeflag, int nudgewhat, int nudgeunits, value, bool reverse, int copies)
boolean reaper.ApplyNudge(ReaProject project, integer nudgeflag, integer nudgewhat, integer nudgeunits, number value, boolean reverse, integer copies)
Boolean RPR_ApplyNudge(ReaProject project, Int nudgeflag, Int nudgewhat, Int nudgeunits, Float value, Boolean reverse, Int copies)

nudgeflag: &1=set to value (otherwise nudge by value), &2=snap
nudgewhat: 0=position, 1=left trim, 2=left edge, 3=right edge, 4=contents, 5=duplicate, 6=edit cursor
nudgeunit: 0=ms, 1=seconds, 2=grid, 3=256th notes, ..., 15=whole notes, 16=measures.beats (1.15 = 1 measure + 1.5 beats), 17=samples, 18=frames, 19=pixels, 20=item lengths, 21=item selections
value: amount to nudge by, or value to set to
reverse: in nudge mode, nudges left (otherwise ignored)
copies: in nudge duplicate mode, number of copies (otherwise ignored)

void ArmCommand(int cmd, const char* sectionname)
ArmCommand(int cmd, "sectionname")
reaper.ArmCommand(integer cmd, string sectionname)
RPR_ArmCommand(Int cmd, String sectionname)

arms a command (or disarms if 0 passed) in section sectionname (empty string for main)

void Audio_Init()
Audio_Init()
reaper.Audio_Init()
RPR_Audio_Init()

open all audio and MIDI devices, if not open

int Audio_IsPreBuffer()
int Audio_IsPreBuffer()
integer reaper.Audio_IsPreBuffer()
Int RPR_Audio_IsPreBuffer()

is in pre-buffer? threadsafe

int Audio_IsRunning()
int Audio_IsRunning()
integer reaper.Audio_IsRunning()
Int RPR_Audio_IsRunning()

is audio running at all? threadsafe

void Audio_Quit()
Audio_Quit()
reaper.Audio_Quit()
RPR_Audio_Quit()

close all audio and MIDI devices, if open

bool AudioAccessorStateChanged(AudioAccessor* accessor)
bool AudioAccessorStateChanged(AudioAccessor accessor)
boolean reaper.AudioAccessorStateChanged(AudioAccessor accessor)
Boolean RPR_AudioAccessorStateChanged(AudioAccessor accessor)

Returns true if the underlying samples (track or media item take) have changed, but does not update the audio accessor, so the user can selectively call AudioAccessorValidateState only when needed. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, GetAudioAccessorEndTime, GetAudioAccessorSamples.

void AudioAccessorUpdate(AudioAccessor* accessor)
AudioAccessorUpdate(AudioAccessor accessor)
reaper.AudioAccessorUpdate(AudioAccessor accessor)
RPR_AudioAccessorUpdate(AudioAccessor accessor)

Force the accessor to reload its state from the underlying track or media item take. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime, GetAudioAccessorSamples.

bool AudioAccessorValidateState(AudioAccessor* accessor)
bool AudioAccessorValidateState(AudioAccessor accessor)
boolean reaper.AudioAccessorValidateState(AudioAccessor accessor)
Boolean RPR_AudioAccessorValidateState(AudioAccessor accessor)

Validates the current state of the audio accessor -- must ONLY call this from the main thread. Returns true if the state changed.

void BypassFxAllTracks(int bypass)
BypassFxAllTracks(int bypass)
reaper.BypassFxAllTracks(integer bypass)
RPR_BypassFxAllTracks(Int bypass)

-1 = bypass all if not all bypassed,otherwise unbypass all

int CalcMediaSrcLoudness(PCM_source* mediasource)
int CalcMediaSrcLoudness(PCM_source mediasource)
integer reaper.CalcMediaSrcLoudness(PCM_source mediasource)
Int RPR_CalcMediaSrcLoudness(PCM_source mediasource)

Calculates loudness statistics of media via dry run render. Statistics will be displayed to the user; call GetSetProjectInfo_String("RENDER_STATS") to retrieve via API. Returns 1 if loudness was calculated successfully, -1 if user canceled the dry run render.

double CalculateNormalization(PCM_source* source, int normalizeTo, double normalizeTarget, double normalizeStart, double normalizeEnd)
double CalculateNormalization(PCM_source source, int normalizeTo, normalizeTarget, normalizeStart, normalizeEnd)
number reaper.CalculateNormalization(PCM_source source, integer normalizeTo, number normalizeTarget, number normalizeStart, number normalizeEnd)
Float RPR_CalculateNormalization(PCM_source source, Int normalizeTo, Float normalizeTarget, Float normalizeStart, Float normalizeEnd)

Calculate normalize adjustment for source media. normalizeTo: 0=LUFS-I, 1=RMS-I, 2=peak, 3=true peak, 4=LUFS-M max, 5=LUFS-S max. normalizeTarget: dBFS or LUFS value. normalizeStart, normalizeEnd: time bounds within source media for normalization calculation. If normalizationStart=0 and normalizationEnd=0, the full duration of the media will be used for the calculation.

void ClearAllRecArmed()
ClearAllRecArmed()
reaper.ClearAllRecArmed()
RPR_ClearAllRecArmed()
void ClearConsole()
ClearConsole()
reaper.ClearConsole()
RPR_ClearConsole()

Clear the ReaScript console. See ShowConsoleMsg

void ClearPeakCache()
ClearPeakCache()
reaper.ClearPeakCache()
RPR_ClearPeakCache()

resets the global peak caches

void ColorFromNative(int col, int* rOut, int* gOut, int* bOut)
ColorFromNative(int col, int &r, int &g, int &b)
integer r, integer g, integer b = reaper.ColorFromNative(integer col)
(Int col, Int rOut, Int gOut, Int bOut) = RPR_ColorFromNative(col, rOut, gOut, bOut)

Extract RGB values from an OS dependent color. See ColorToNative.

int ColorToNative(int r, int g, int b)
int ColorToNative(int r, int g, int b)
integer reaper.ColorToNative(integer r, integer g, integer b)
Int RPR_ColorToNative(Int r, Int g, Int b)

Make an OS dependent color from RGB values (e.g. RGB() macro on Windows). r,g and b are in [0..255]. See ColorFromNative.

int CountActionShortcuts(KbdSectionInfo* section, int cmdID)
int CountActionShortcuts(KbdSectionInfo section, int cmdID)
integer reaper.CountActionShortcuts(KbdSectionInfo section, integer cmdID)
Int RPR_CountActionShortcuts(KbdSectionInfo section, Int cmdID)

Returns the number of shortcuts that exist for the given command ID.
see GetActionShortcutDesc, DeleteActionShortcut, DoActionShortcutDialog.

int CountAutomationItems(TrackEnvelope* env)
int CountAutomationItems(TrackEnvelope env)
integer reaper.CountAutomationItems(TrackEnvelope env)
Int RPR_CountAutomationItems(TrackEnvelope env)

Returns the number of automation items on this envelope. See GetSetAutomationItemInfo

int CountEnvelopePoints(TrackEnvelope* envelope)
int CountEnvelopePoints(TrackEnvelope envelope)
integer reaper.CountEnvelopePoints(TrackEnvelope envelope)
Int RPR_CountEnvelopePoints(TrackEnvelope envelope)

Returns the number of points in the envelope. See CountEnvelopePointsEx.

int CountEnvelopePointsEx(TrackEnvelope* envelope, int autoitem_idx)
int CountEnvelopePointsEx(TrackEnvelope envelope, int autoitem_idx)
integer reaper.CountEnvelopePointsEx(TrackEnvelope envelope, integer autoitem_idx)
Int RPR_CountEnvelopePointsEx(TrackEnvelope envelope, Int autoitem_idx)

Returns the number of points in the envelope.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See GetEnvelopePointEx, SetEnvelopePointEx, InsertEnvelopePointEx, DeleteEnvelopePointEx.

int CountMediaItems(ReaProject* proj)
int CountMediaItems(ReaProject proj)
integer reaper.CountMediaItems(ReaProject proj)
Int RPR_CountMediaItems(ReaProject proj)

count the number of items in the project (proj=0 for active project)

int CountProjectMarkers(ReaProject* proj, int* num_markersOut, int* num_regionsOut)
int CountProjectMarkers(ReaProject proj, int &num_markers, int &num_regions)
integer retval, integer num_markers, integer num_regions = reaper.CountProjectMarkers(ReaProject proj)
(Int retval, ReaProject proj, Int num_markersOut, Int num_regionsOut) = RPR_CountProjectMarkers(proj, num_markersOut, num_regionsOut)

num_markersOut and num_regionsOut may be NULL.

int CountSelectedMediaItems(ReaProject* proj)
int CountSelectedMediaItems(ReaProject proj)
integer reaper.CountSelectedMediaItems(ReaProject proj)
Int RPR_CountSelectedMediaItems(ReaProject proj)

count the number of selected items in the project (proj=0 for active project)

int CountSelectedTracks(ReaProject* proj)
int CountSelectedTracks(ReaProject proj)
integer reaper.CountSelectedTracks(ReaProject proj)
Int RPR_CountSelectedTracks(ReaProject proj)

Count the number of selected tracks in the project (proj=0 for active project). This function ignores the master track, see CountSelectedTracks2.

int CountSelectedTracks2(ReaProject* proj, bool wantmaster)
int CountSelectedTracks2(ReaProject proj, bool wantmaster)
integer reaper.CountSelectedTracks2(ReaProject proj, boolean wantmaster)
Int RPR_CountSelectedTracks2(ReaProject proj, Boolean wantmaster)

Count the number of selected tracks in the project (proj=0 for active project).

int CountTakeEnvelopes(MediaItem_Take* take)
int CountTakeEnvelopes(MediaItem_Take take)
integer reaper.CountTakeEnvelopes(MediaItem_Take take)
Int RPR_CountTakeEnvelopes(MediaItem_Take take)

See GetTakeEnvelope

int CountTakes(MediaItem* item)
int CountTakes(MediaItem item)
integer reaper.CountTakes(MediaItem item)
Int RPR_CountTakes(MediaItem item)

count the number of takes in the item

int CountTCPFXParms(ReaProject* project, MediaTrack* track)
int CountTCPFXParms(ReaProject project, MediaTrack track)
integer reaper.CountTCPFXParms(ReaProject project, MediaTrack track)
Int RPR_CountTCPFXParms(ReaProject project, MediaTrack track)

Count the number of FX parameter knobs displayed on the track control panel.

int CountTempoTimeSigMarkers(ReaProject* proj)
int CountTempoTimeSigMarkers(ReaProject proj)
integer reaper.CountTempoTimeSigMarkers(ReaProject proj)
Int RPR_CountTempoTimeSigMarkers(ReaProject proj)

Count the number of tempo/time signature markers in the project. See GetTempoTimeSigMarker, SetTempoTimeSigMarker, AddTempoTimeSigMarker.

int CountTrackEnvelopes(MediaTrack* track)
int CountTrackEnvelopes(MediaTrack track)
integer reaper.CountTrackEnvelopes(MediaTrack track)
Int RPR_CountTrackEnvelopes(MediaTrack track)

see GetTrackEnvelope

int CountTrackMediaItems(MediaTrack* track)
int CountTrackMediaItems(MediaTrack track)
integer reaper.CountTrackMediaItems(MediaTrack track)
Int RPR_CountTrackMediaItems(MediaTrack track)

count the number of items in the track

int CountTracks(ReaProject* projOptional)
int CountTracks(ReaProject proj)
integer reaper.CountTracks(ReaProject proj)
Int RPR_CountTracks(ReaProject projOptional)

count the number of tracks in the project (proj=0 for active project)

MediaItem* CreateNewMIDIItemInProj(MediaTrack* track, double starttime, double endtime, const bool* qnInOptional)
MediaItem CreateNewMIDIItemInProj(MediaTrack track, starttime, endtime, optional bool qnIn)
MediaItem reaper.CreateNewMIDIItemInProj(MediaTrack track, number starttime, number endtime, optional boolean qnIn)
MediaItem RPR_CreateNewMIDIItemInProj(MediaTrack track, Float starttime, Float endtime, const bool qnInOptional)

Create a new MIDI media item, containing no MIDI events. Time is in seconds unless qn is set.

AudioAccessor* CreateTakeAudioAccessor(MediaItem_Take* take)
AudioAccessor CreateTakeAudioAccessor(MediaItem_Take take)
AudioAccessor reaper.CreateTakeAudioAccessor(MediaItem_Take take)
AudioAccessor RPR_CreateTakeAudioAccessor(MediaItem_Take take)

Create an audio accessor object for this take. Must only call from the main thread. See CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime, GetAudioAccessorSamples.

AudioAccessor* CreateTrackAudioAccessor(MediaTrack* track)
AudioAccessor CreateTrackAudioAccessor(MediaTrack track)
AudioAccessor reaper.CreateTrackAudioAccessor(MediaTrack track)
AudioAccessor RPR_CreateTrackAudioAccessor(MediaTrack track)

Create an audio accessor object for this track. Must only call from the main thread. See CreateTakeAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime, GetAudioAccessorSamples.

int CreateTrackSend(MediaTrack* tr, MediaTrack* desttrInOptional)
int CreateTrackSend(MediaTrack tr, MediaTrack desttrIn)
integer reaper.CreateTrackSend(MediaTrack tr, MediaTrack desttrIn)
Int RPR_CreateTrackSend(MediaTrack tr, MediaTrack desttrInOptional)

Create a send/receive (desttrInOptional!=NULL), or a hardware output (desttrInOptional==NULL) with default properties, return >=0 on success (== new send/receive index). See RemoveTrackSend, GetSetTrackSendInfo, GetTrackSendInfo_Value, SetTrackSendInfo_Value.

void CSurf_FlushUndo(bool force)
CSurf_FlushUndo(bool force)
reaper.CSurf_FlushUndo(boolean force)
RPR_CSurf_FlushUndo(Boolean force)

call this to force flushing of the undo states after using CSurf_On*Change()

bool CSurf_GetTouchState(MediaTrack* trackid, int isPan)
bool CSurf_GetTouchState(MediaTrack trackid, int isPan)
boolean reaper.CSurf_GetTouchState(MediaTrack trackid, integer isPan)
Boolean RPR_CSurf_GetTouchState(MediaTrack trackid, Int isPan)
void CSurf_GoEnd()
CSurf_GoEnd()
reaper.CSurf_GoEnd()
RPR_CSurf_GoEnd()
void CSurf_GoStart()
CSurf_GoStart()
reaper.CSurf_GoStart()
RPR_CSurf_GoStart()
int CSurf_NumTracks(bool mcpView)
int CSurf_NumTracks(bool mcpView)
integer reaper.CSurf_NumTracks(boolean mcpView)
Int RPR_CSurf_NumTracks(Boolean mcpView)
void CSurf_OnArrow(int whichdir, bool wantzoom)
CSurf_OnArrow(int whichdir, bool wantzoom)
reaper.CSurf_OnArrow(integer whichdir, boolean wantzoom)
RPR_CSurf_OnArrow(Int whichdir, Boolean wantzoom)
void CSurf_OnFwd(int seekplay)
CSurf_OnFwd(int seekplay)
reaper.CSurf_OnFwd(integer seekplay)
RPR_CSurf_OnFwd(Int seekplay)
bool CSurf_OnFXChange(MediaTrack* trackid, int en)
bool CSurf_OnFXChange(MediaTrack trackid, int en)
boolean reaper.CSurf_OnFXChange(MediaTrack trackid, integer en)
Boolean RPR_CSurf_OnFXChange(MediaTrack trackid, Int en)
int CSurf_OnInputMonitorChange(MediaTrack* trackid, int monitor)
int CSurf_OnInputMonitorChange(MediaTrack trackid, int monitor)
integer reaper.CSurf_OnInputMonitorChange(MediaTrack trackid, integer monitor)
Int RPR_CSurf_OnInputMonitorChange(MediaTrack trackid, Int monitor)
int CSurf_OnInputMonitorChangeEx(MediaTrack* trackid, int monitor, bool allowgang)
int CSurf_OnInputMonitorChangeEx(MediaTrack trackid, int monitor, bool allowgang)
integer reaper.CSurf_OnInputMonitorChangeEx(MediaTrack trackid, integer monitor, boolean allowgang)
Int RPR_CSurf_OnInputMonitorChangeEx(MediaTrack trackid, Int monitor, Boolean allowgang)
bool CSurf_OnMuteChange(MediaTrack* trackid, int mute)
bool CSurf_OnMuteChange(MediaTrack trackid, int mute)
boolean reaper.CSurf_OnMuteChange(MediaTrack trackid, integer mute)
Boolean RPR_CSurf_OnMuteChange(MediaTrack trackid, Int mute)
bool CSurf_OnMuteChangeEx(MediaTrack* trackid, int mute, bool allowgang)
bool CSurf_OnMuteChangeEx(MediaTrack trackid, int mute, bool allowgang)
boolean reaper.CSurf_OnMuteChangeEx(MediaTrack trackid, integer mute, boolean allowgang)
Boolean RPR_CSurf_OnMuteChangeEx(MediaTrack trackid, Int mute, Boolean allowgang)
double CSurf_OnPanChange(MediaTrack* trackid, double pan, bool relative)
double CSurf_OnPanChange(MediaTrack trackid, pan, bool relative)
number reaper.CSurf_OnPanChange(MediaTrack trackid, number pan, boolean relative)
Float RPR_CSurf_OnPanChange(MediaTrack trackid, Float pan, Boolean relative)
double CSurf_OnPanChangeEx(MediaTrack* trackid, double pan, bool relative, bool allowGang)
double CSurf_OnPanChangeEx(MediaTrack trackid, pan, bool relative, bool allowGang)
number reaper.CSurf_OnPanChangeEx(MediaTrack trackid, number pan, boolean relative, boolean allowGang)
Float RPR_CSurf_OnPanChangeEx(MediaTrack trackid, Float pan, Boolean relative, Boolean allowGang)
void CSurf_OnPause()
CSurf_OnPause()
reaper.CSurf_OnPause()
RPR_CSurf_OnPause()
void CSurf_OnPlay()
CSurf_OnPlay()
reaper.CSurf_OnPlay()
RPR_CSurf_OnPlay()
void CSurf_OnPlayRateChange(double playrate)
CSurf_OnPlayRateChange(playrate)
reaper.CSurf_OnPlayRateChange(number playrate)
RPR_CSurf_OnPlayRateChange(Float playrate)
bool CSurf_OnRecArmChange(MediaTrack* trackid, int recarm)
bool CSurf_OnRecArmChange(MediaTrack trackid, int recarm)
boolean reaper.CSurf_OnRecArmChange(MediaTrack trackid, integer recarm)
Boolean RPR_CSurf_OnRecArmChange(MediaTrack trackid, Int recarm)
bool CSurf_OnRecArmChangeEx(MediaTrack* trackid, int recarm, bool allowgang)
bool CSurf_OnRecArmChangeEx(MediaTrack trackid, int recarm, bool allowgang)
boolean reaper.CSurf_OnRecArmChangeEx(MediaTrack trackid, integer recarm, boolean allowgang)
Boolean RPR_CSurf_OnRecArmChangeEx(MediaTrack trackid, Int recarm, Boolean allowgang)
void CSurf_OnRecord()
CSurf_OnRecord()
reaper.CSurf_OnRecord()
RPR_CSurf_OnRecord()
double CSurf_OnRecvPanChange(MediaTrack* trackid, int recv_index, double pan, bool relative)
double CSurf_OnRecvPanChange(MediaTrack trackid, int recv_index, pan, bool relative)
number reaper.CSurf_OnRecvPanChange(MediaTrack trackid, integer recv_index, number pan, boolean relative)
Float RPR_CSurf_OnRecvPanChange(MediaTrack trackid, Int recv_index, Float pan, Boolean relative)
double CSurf_OnRecvVolumeChange(MediaTrack* trackid, int recv_index, double volume, bool relative)
double CSurf_OnRecvVolumeChange(MediaTrack trackid, int recv_index, volume, bool relative)
number reaper.CSurf_OnRecvVolumeChange(MediaTrack trackid, integer recv_index, number volume, boolean relative)
Float RPR_CSurf_OnRecvVolumeChange(MediaTrack trackid, Int recv_index, Float volume, Boolean relative)
void CSurf_OnRew(int seekplay)
CSurf_OnRew(int seekplay)
reaper.CSurf_OnRew(integer seekplay)
RPR_CSurf_OnRew(Int seekplay)
void CSurf_OnRewFwd(int seekplay, int dir)
CSurf_OnRewFwd(int seekplay, int dir)
reaper.CSurf_OnRewFwd(integer seekplay, integer dir)
RPR_CSurf_OnRewFwd(Int seekplay, Int dir)
void CSurf_OnScroll(int xdir, int ydir)
CSurf_OnScroll(int xdir, int ydir)
reaper.CSurf_OnScroll(integer xdir, integer ydir)
RPR_CSurf_OnScroll(Int xdir, Int ydir)
bool CSurf_OnSelectedChange(MediaTrack* trackid, int selected)
bool CSurf_OnSelectedChange(MediaTrack trackid, int selected)
boolean reaper.CSurf_OnSelectedChange(MediaTrack trackid, integer selected)
Boolean RPR_CSurf_OnSelectedChange(MediaTrack trackid, Int selected)
double CSurf_OnSendPanChange(MediaTrack* trackid, int send_index, double pan, bool relative)
double CSurf_OnSendPanChange(MediaTrack trackid, int send_index, pan, bool relative)
number reaper.CSurf_OnSendPanChange(MediaTrack trackid, integer send_index, number pan, boolean relative)
Float RPR_CSurf_OnSendPanChange(MediaTrack trackid, Int send_index, Float pan, Boolean relative)
double CSurf_OnSendVolumeChange(MediaTrack* trackid, int send_index, double volume, bool relative)
double CSurf_OnSendVolumeChange(MediaTrack trackid, int send_index, volume, bool relative)
number reaper.CSurf_OnSendVolumeChange(MediaTrack trackid, integer send_index, number volume, boolean relative)
Float RPR_CSurf_OnSendVolumeChange(MediaTrack trackid, Int send_index, Float volume, Boolean relative)
bool CSurf_OnSoloChange(MediaTrack* trackid, int solo)
bool CSurf_OnSoloChange(MediaTrack trackid, int solo)
boolean reaper.CSurf_OnSoloChange(MediaTrack trackid, integer solo)
Boolean RPR_CSurf_OnSoloChange(MediaTrack trackid, Int solo)
bool CSurf_OnSoloChangeEx(MediaTrack* trackid, int solo, bool allowgang)
bool CSurf_OnSoloChangeEx(MediaTrack trackid, int solo, bool allowgang)
boolean reaper.CSurf_OnSoloChangeEx(MediaTrack trackid, integer solo, boolean allowgang)
Boolean RPR_CSurf_OnSoloChangeEx(MediaTrack trackid, Int solo, Boolean allowgang)
void CSurf_OnStop()
CSurf_OnStop()
reaper.CSurf_OnStop()
RPR_CSurf_OnStop()
void CSurf_OnTempoChange(double bpm)
CSurf_OnTempoChange(bpm)
reaper.CSurf_OnTempoChange(number bpm)
RPR_CSurf_OnTempoChange(Float bpm)
void CSurf_OnTrackSelection(MediaTrack* trackid)
CSurf_OnTrackSelection(MediaTrack trackid)
reaper.CSurf_OnTrackSelection(MediaTrack trackid)
RPR_CSurf_OnTrackSelection(MediaTrack trackid)
double CSurf_OnVolumeChange(MediaTrack* trackid, double volume, bool relative)
double CSurf_OnVolumeChange(MediaTrack trackid, volume, bool relative)
number reaper.CSurf_OnVolumeChange(MediaTrack trackid, number volume, boolean relative)
Float RPR_CSurf_OnVolumeChange(MediaTrack trackid, Float volume, Boolean relative)
double CSurf_OnVolumeChangeEx(MediaTrack* trackid, double volume, bool relative, bool allowGang)
double CSurf_OnVolumeChangeEx(MediaTrack trackid, volume, bool relative, bool allowGang)
number reaper.CSurf_OnVolumeChangeEx(MediaTrack trackid, number volume, boolean relative, boolean allowGang)
Float RPR_CSurf_OnVolumeChangeEx(MediaTrack trackid, Float volume, Boolean relative, Boolean allowGang)
double CSurf_OnWidthChange(MediaTrack* trackid, double width, bool relative)
double CSurf_OnWidthChange(MediaTrack trackid, width, bool relative)
number reaper.CSurf_OnWidthChange(MediaTrack trackid, number width, boolean relative)
Float RPR_CSurf_OnWidthChange(MediaTrack trackid, Float width, Boolean relative)
double CSurf_OnWidthChangeEx(MediaTrack* trackid, double width, bool relative, bool allowGang)
double CSurf_OnWidthChangeEx(MediaTrack trackid, width, bool relative, bool allowGang)
number reaper.CSurf_OnWidthChangeEx(MediaTrack trackid, number width, boolean relative, boolean allowGang)
Float RPR_CSurf_OnWidthChangeEx(MediaTrack trackid, Float width, Boolean relative, Boolean allowGang)
void CSurf_OnZoom(int xdir, int ydir)
CSurf_OnZoom(int xdir, int ydir)
reaper.CSurf_OnZoom(integer xdir, integer ydir)
RPR_CSurf_OnZoom(Int xdir, Int ydir)
void CSurf_ResetAllCachedVolPanStates()
CSurf_ResetAllCachedVolPanStates()
reaper.CSurf_ResetAllCachedVolPanStates()
RPR_CSurf_ResetAllCachedVolPanStates()
void CSurf_ScrubAmt(double amt)
CSurf_ScrubAmt(amt)
reaper.CSurf_ScrubAmt(number amt)
RPR_CSurf_ScrubAmt(Float amt)
void CSurf_SetAutoMode(int mode, IReaperControlSurface* ignoresurf)
CSurf_SetAutoMode(int mode, IReaperControlSurface ignoresurf)
reaper.CSurf_SetAutoMode(integer mode, IReaperControlSurface ignoresurf)
RPR_CSurf_SetAutoMode(Int mode, IReaperControlSurface ignoresurf)
void CSurf_SetPlayState(bool play, bool pause, bool rec, IReaperControlSurface* ignoresurf)
CSurf_SetPlayState(bool play, bool pause, bool rec, IReaperControlSurface ignoresurf)
reaper.CSurf_SetPlayState(boolean play, boolean pause, boolean rec, IReaperControlSurface ignoresurf)
RPR_CSurf_SetPlayState(Boolean play, Boolean pause, Boolean rec, IReaperControlSurface ignoresurf)
void CSurf_SetRepeatState(bool rep, IReaperControlSurface* ignoresurf)
CSurf_SetRepeatState(bool rep, IReaperControlSurface ignoresurf)
reaper.CSurf_SetRepeatState(boolean rep, IReaperControlSurface ignoresurf)
RPR_CSurf_SetRepeatState(Boolean rep, IReaperControlSurface ignoresurf)
void CSurf_SetSurfaceMute(MediaTrack* trackid, bool mute, IReaperControlSurface* ignoresurf)
CSurf_SetSurfaceMute(MediaTrack trackid, bool mute, IReaperControlSurface ignoresurf)
reaper.CSurf_SetSurfaceMute(MediaTrack trackid, boolean mute, IReaperControlSurface ignoresurf)
RPR_CSurf_SetSurfaceMute(MediaTrack trackid, Boolean mute, IReaperControlSurface ignoresurf)
void CSurf_SetSurfacePan(MediaTrack* trackid, double pan, IReaperControlSurface* ignoresurf)
CSurf_SetSurfacePan(MediaTrack trackid, pan, IReaperControlSurface ignoresurf)
reaper.CSurf_SetSurfacePan(MediaTrack trackid, number pan, IReaperControlSurface ignoresurf)
RPR_CSurf_SetSurfacePan(MediaTrack trackid, Float pan, IReaperControlSurface ignoresurf)
void CSurf_SetSurfaceRecArm(MediaTrack* trackid, bool recarm, IReaperControlSurface* ignoresurf)
CSurf_SetSurfaceRecArm(MediaTrack trackid, bool recarm, IReaperControlSurface ignoresurf)
reaper.CSurf_SetSurfaceRecArm(MediaTrack trackid, boolean recarm, IReaperControlSurface ignoresurf)
RPR_CSurf_SetSurfaceRecArm(MediaTrack trackid, Boolean recarm, IReaperControlSurface ignoresurf)
void CSurf_SetSurfaceSelected(MediaTrack* trackid, bool selected, IReaperControlSurface* ignoresurf)
CSurf_SetSurfaceSelected(MediaTrack trackid, bool selected, IReaperControlSurface ignoresurf)
reaper.CSurf_SetSurfaceSelected(MediaTrack trackid, boolean selected, IReaperControlSurface ignoresurf)
RPR_CSurf_SetSurfaceSelected(MediaTrack trackid, Boolean selected, IReaperControlSurface ignoresurf)
void CSurf_SetSurfaceSolo(MediaTrack* trackid, bool solo, IReaperControlSurface* ignoresurf)
CSurf_SetSurfaceSolo(MediaTrack trackid, bool solo, IReaperControlSurface ignoresurf)
reaper.CSurf_SetSurfaceSolo(MediaTrack trackid, boolean solo, IReaperControlSurface ignoresurf)
RPR_CSurf_SetSurfaceSolo(MediaTrack trackid, Boolean solo, IReaperControlSurface ignoresurf)
void CSurf_SetSurfaceVolume(MediaTrack* trackid, double volume, IReaperControlSurface* ignoresurf)
CSurf_SetSurfaceVolume(MediaTrack trackid, volume, IReaperControlSurface ignoresurf)
reaper.CSurf_SetSurfaceVolume(MediaTrack trackid, number volume, IReaperControlSurface ignoresurf)
RPR_CSurf_SetSurfaceVolume(MediaTrack trackid, Float volume, IReaperControlSurface ignoresurf)
void CSurf_SetTrackListChange()
CSurf_SetTrackListChange()
reaper.CSurf_SetTrackListChange()
RPR_CSurf_SetTrackListChange()
MediaTrack* CSurf_TrackFromID(int idx, bool mcpView)
MediaTrack CSurf_TrackFromID(int idx, bool mcpView)
MediaTrack reaper.CSurf_TrackFromID(integer idx, boolean mcpView)
MediaTrack RPR_CSurf_TrackFromID(Int idx, Boolean mcpView)
int CSurf_TrackToID(MediaTrack* track, bool mcpView)
int CSurf_TrackToID(MediaTrack track, bool mcpView)
integer reaper.CSurf_TrackToID(MediaTrack track, boolean mcpView)
Int RPR_CSurf_TrackToID(MediaTrack track, Boolean mcpView)
double DB2SLIDER(double x)
double DB2SLIDER(x)
number reaper.DB2SLIDER(number x)
Float RPR_DB2SLIDER(Float x)
bool DeleteActionShortcut(KbdSectionInfo* section, int cmdID, int shortcutidx)
bool DeleteActionShortcut(KbdSectionInfo section, int cmdID, int shortcutidx)
boolean reaper.DeleteActionShortcut(KbdSectionInfo section, integer cmdID, integer shortcutidx)
Boolean RPR_DeleteActionShortcut(KbdSectionInfo section, Int cmdID, Int shortcutidx)

Delete the specific shortcut for the given command ID.
See CountActionShortcuts, GetActionShortcutDesc, DoActionShortcutDialog.

bool DeleteEnvelopePointEx(TrackEnvelope* envelope, int autoitem_idx, int ptidx)
bool DeleteEnvelopePointEx(TrackEnvelope envelope, int autoitem_idx, int ptidx)
boolean reaper.DeleteEnvelopePointEx(TrackEnvelope envelope, integer autoitem_idx, integer ptidx)
Boolean RPR_DeleteEnvelopePointEx(TrackEnvelope envelope, Int autoitem_idx, Int ptidx)

Delete an envelope point. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See CountEnvelopePointsEx, GetEnvelopePointEx, SetEnvelopePointEx, InsertEnvelopePointEx.

bool DeleteEnvelopePointRange(TrackEnvelope* envelope, double time_start, double time_end)
bool DeleteEnvelopePointRange(TrackEnvelope envelope, time_start, time_end)
boolean reaper.DeleteEnvelopePointRange(TrackEnvelope envelope, number time_start, number time_end)
Boolean RPR_DeleteEnvelopePointRange(TrackEnvelope envelope, Float time_start, Float time_end)

Delete a range of envelope points. See DeleteEnvelopePointRangeEx, DeleteEnvelopePointEx.

bool DeleteEnvelopePointRangeEx(TrackEnvelope* envelope, int autoitem_idx, double time_start, double time_end)
bool DeleteEnvelopePointRangeEx(TrackEnvelope envelope, int autoitem_idx, time_start, time_end)
boolean reaper.DeleteEnvelopePointRangeEx(TrackEnvelope envelope, integer autoitem_idx, number time_start, number time_end)
Boolean RPR_DeleteEnvelopePointRangeEx(TrackEnvelope envelope, Int autoitem_idx, Float time_start, Float time_end)

Delete a range of envelope points. autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.

void DeleteExtState(const char* section, const char* key, bool persist)
DeleteExtState("section", "key", bool persist)
reaper.DeleteExtState(string section, string key, boolean persist)
RPR_DeleteExtState(String section, String key, Boolean persist)

Delete the extended state value for a specific section and key. persist=true means the value should remain deleted the next time REAPER is opened. See SetExtState, GetExtState, HasExtState.

bool DeleteProjectMarker(ReaProject* proj, int markrgnindexnumber, bool isrgn)
bool DeleteProjectMarker(ReaProject proj, int markrgnindexnumber, bool isrgn)
boolean reaper.DeleteProjectMarker(ReaProject proj, integer markrgnindexnumber, boolean isrgn)
Boolean RPR_DeleteProjectMarker(ReaProject proj, Int markrgnindexnumber, Boolean isrgn)

Delete a marker. proj==NULL for the active project.

bool DeleteProjectMarkerByIndex(ReaProject* proj, int markrgnidx)
bool DeleteProjectMarkerByIndex(ReaProject proj, int markrgnidx)
boolean reaper.DeleteProjectMarkerByIndex(ReaProject proj, integer markrgnidx)
Boolean RPR_DeleteProjectMarkerByIndex(ReaProject proj, Int markrgnidx)

Differs from DeleteProjectMarker only in that markrgnidx is 0 for the first marker/region, 1 for the next, etc (see EnumProjectMarkers3), rather than representing the displayed marker/region ID number (see SetProjectMarker4).

bool DeleteTakeMarker(MediaItem_Take* take, int idx)
bool DeleteTakeMarker(MediaItem_Take take, int idx)
boolean reaper.DeleteTakeMarker(MediaItem_Take take, integer idx)
Boolean RPR_DeleteTakeMarker(MediaItem_Take take, Int idx)

Delete a take marker. Note that idx will change for all following take markers. See GetNumTakeMarkers, GetTakeMarker, SetTakeMarker

int DeleteTakeStretchMarkers(MediaItem_Take* take, int idx, const int* countInOptional)
int DeleteTakeStretchMarkers(MediaItem_Take take, int idx, optional int countIn)
integer reaper.DeleteTakeStretchMarkers(MediaItem_Take take, integer idx, optional integer countIn)
Int RPR_DeleteTakeStretchMarkers(MediaItem_Take take, Int idx, const int countInOptional)

Deletes one or more stretch markers. Returns number of stretch markers deleted.

bool DeleteTempoTimeSigMarker(ReaProject* project, int markerindex)
bool DeleteTempoTimeSigMarker(ReaProject project, int markerindex)
boolean reaper.DeleteTempoTimeSigMarker(ReaProject project, integer markerindex)
Boolean RPR_DeleteTempoTimeSigMarker(ReaProject project, Int markerindex)

Delete a tempo/time signature marker.

void DeleteTrack(MediaTrack* tr)
DeleteTrack(MediaTrack tr)
reaper.DeleteTrack(MediaTrack tr)
RPR_DeleteTrack(MediaTrack tr)

deletes a track

bool DeleteTrackMediaItem(MediaTrack* tr, MediaItem* it)
bool DeleteTrackMediaItem(MediaTrack tr, MediaItem it)
boolean reaper.DeleteTrackMediaItem(MediaTrack tr, MediaItem it)
Boolean RPR_DeleteTrackMediaItem(MediaTrack tr, MediaItem it)
void DestroyAudioAccessor(AudioAccessor* accessor)
DestroyAudioAccessor(AudioAccessor accessor)
reaper.DestroyAudioAccessor(AudioAccessor accessor)
RPR_DestroyAudioAccessor(AudioAccessor accessor)

Destroy an audio accessor. Must only call from the main thread. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime, GetAudioAccessorSamples.

bool DoActionShortcutDialog(HWND hwnd, KbdSectionInfo* section, int cmdID, int shortcutidx)
bool DoActionShortcutDialog(HWND hwnd, KbdSectionInfo section, int cmdID, int shortcutidx)
boolean reaper.DoActionShortcutDialog(HWND hwnd, KbdSectionInfo section, integer cmdID, integer shortcutidx)
Boolean RPR_DoActionShortcutDialog(HWND hwnd, KbdSectionInfo section, Int cmdID, Int shortcutidx)

Open the action shortcut dialog to edit or add a shortcut for the given command ID. If (shortcutidx >= 0 && shortcutidx < CountActionShortcuts()), that specific shortcut will be replaced, otherwise a new shortcut will be added.
See CountActionShortcuts, GetActionShortcutDesc, DeleteActionShortcut.

void Dock_UpdateDockID(const char* ident_str, int whichDock)
Dock_UpdateDockID("ident_str", int whichDock)
reaper.Dock_UpdateDockID(string ident_str, integer whichDock)
RPR_Dock_UpdateDockID(String ident_str, Int whichDock)

updates preference for docker window ident_str to be in dock whichDock on next open

int DockGetPosition(int whichDock)
int DockGetPosition(int whichDock)
integer reaper.DockGetPosition(integer whichDock)
Int RPR_DockGetPosition(Int whichDock)

-1=not found, 0=bottom, 1=left, 2=top, 3=right, 4=floating

int DockIsChildOfDock(HWND hwnd, bool* isFloatingDockerOut)
int DockIsChildOfDock(HWND hwnd, bool &isFloatingDocker)
integer retval, boolean isFloatingDocker = reaper.DockIsChildOfDock(HWND hwnd)
(Int retval, HWND hwnd, Boolean isFloatingDockerOut) = RPR_DockIsChildOfDock(hwnd, isFloatingDockerOut)

returns dock index that contains hwnd, or -1

void DockWindowActivate(HWND hwnd)
DockWindowActivate(HWND hwnd)
reaper.DockWindowActivate(HWND hwnd)
RPR_DockWindowActivate(HWND hwnd)
void DockWindowAdd(HWND hwnd, const char* name, int pos, bool allowShow)
DockWindowAdd(HWND hwnd, "name", int pos, bool allowShow)
reaper.DockWindowAdd(HWND hwnd, string name, integer pos, boolean allowShow)
RPR_DockWindowAdd(HWND hwnd, String name, Int pos, Boolean allowShow)
void DockWindowAddEx(HWND hwnd, const char* name, const char* identstr, bool allowShow)
DockWindowAddEx(HWND hwnd, "name", "identstr", bool allowShow)
reaper.DockWindowAddEx(HWND hwnd, string name, string identstr, boolean allowShow)
RPR_DockWindowAddEx(HWND hwnd, String name, String identstr, Boolean allowShow)
void DockWindowRefresh()
DockWindowRefresh()
reaper.DockWindowRefresh()
RPR_DockWindowRefresh()
void DockWindowRefreshForHWND(HWND hwnd)
DockWindowRefreshForHWND(HWND hwnd)
reaper.DockWindowRefreshForHWND(HWND hwnd)
RPR_DockWindowRefreshForHWND(HWND hwnd)
void DockWindowRemove(HWND hwnd)
DockWindowRemove(HWND hwnd)
reaper.DockWindowRemove(HWND hwnd)
RPR_DockWindowRemove(HWND hwnd)
bool EditTempoTimeSigMarker(ReaProject* project, int markerindex)
bool EditTempoTimeSigMarker(ReaProject project, int markerindex)
boolean reaper.EditTempoTimeSigMarker(ReaProject project, integer markerindex)
Boolean RPR_EditTempoTimeSigMarker(ReaProject project, Int markerindex)

Open the tempo/time signature marker editor dialog.

void EnsureNotCompletelyOffscreen(RECT* rInOut)
EnsureNotCompletelyOffscreen(int &r.left, int &r.top, int &r.right, int &r.bot)
integerr.left, integerr.top, integerr.right, integerr.bot = reaper.EnsureNotCompletelyOffscreen(integerr.left, integerr.top, integerr.right, integerr.bot)
RPR_EnsureNotCompletelyOffscreen(RECT rInOut)

call with a saved window rect for your window and it'll correct any positioning info.

const char* EnumerateFiles(const char* path, int fileindex)
bool EnumerateFiles(#retval, "path", int fileindex)
string reaper.EnumerateFiles(string path, integer fileindex)
String RPR_EnumerateFiles(String path, Int fileindex)

List the files in the "path" directory. Returns NULL/nil when all files have been listed. Use fileindex = -1 to force re-read of directory (invalidate cache). See EnumerateSubdirectories

const char* EnumerateSubdirectories(const char* path, int subdirindex)
bool EnumerateSubdirectories(#retval, "path", int subdirindex)
string reaper.EnumerateSubdirectories(string path, integer subdirindex)
String RPR_EnumerateSubdirectories(String path, Int subdirindex)

List the subdirectories in the "path" directory. Use subdirindex = -1 to force re-read of directory (invalidate cache). Returns NULL/nil when all subdirectories have been listed. See EnumerateFiles

bool EnumInstalledFX(int index, const char** nameOut, const char** identOut)
bool EnumInstalledFX(int index, #name, #ident)
boolean retval, string name, string ident = reaper.EnumInstalledFX(integer index)
Boolean RPR_EnumInstalledFX(Int index, String nameOut, String identOut)

Enumerates installed FX. Returns true if successful, sets nameOut and identOut to name and ident of FX at index.

bool EnumPitchShiftModes(int mode, const char** strOut)
bool EnumPitchShiftModes(int mode, #str)
boolean retval, string str = reaper.EnumPitchShiftModes(integer mode)
Boolean RPR_EnumPitchShiftModes(Int mode, String strOut)

Start querying modes at 0, returns FALSE when no more modes possible, sets strOut to NULL if a mode is currently unsupported

const char* EnumPitchShiftSubModes(int mode, int submode)
bool EnumPitchShiftSubModes(#retval, int mode, int submode)
string reaper.EnumPitchShiftSubModes(integer mode, integer submode)
String RPR_EnumPitchShiftSubModes(Int mode, Int submode)

Returns submode name, or NULL

int EnumProjectMarkers(int idx, bool* isrgnOut, double* posOut, double* rgnendOut, const char** nameOut, int* markrgnindexnumberOut)
int EnumProjectMarkers(int idx, bool &isrgn, &pos, &rgnend, #name, int &markrgnindexnumber)
integer retval, boolean isrgn, number pos, number rgnend, string name, integer markrgnindexnumber = reaper.EnumProjectMarkers(integer idx)
(Int retval, Int idx, Boolean isrgnOut, Float posOut, Float rgnendOut, String nameOut, Int markrgnindexnumberOut) = RPR_EnumProjectMarkers(idx, isrgnOut, posOut, rgnendOut, nameOut, markrgnindexnumberOut)
int EnumProjectMarkers2(ReaProject* proj, int idx, bool* isrgnOut, double* posOut, double* rgnendOut, const char** nameOut, int* markrgnindexnumberOut)
int EnumProjectMarkers2(ReaProject proj, int idx, bool &isrgn, &pos, &rgnend, #name, int &markrgnindexnumber)
integer retval, boolean isrgn, number pos, number rgnend, string name, integer markrgnindexnumber = reaper.EnumProjectMarkers2(ReaProject proj, integer idx)
(Int retval, ReaProject proj, Int idx, Boolean isrgnOut, Float posOut, Float rgnendOut, String nameOut, Int markrgnindexnumberOut) = RPR_EnumProjectMarkers2(proj, idx, isrgnOut, posOut, rgnendOut, nameOut, markrgnindexnumberOut)
int EnumProjectMarkers3(ReaProject* proj, int idx, bool* isrgnOut, double* posOut, double* rgnendOut, const char** nameOut, int* markrgnindexnumberOut, int* colorOut)
int EnumProjectMarkers3(ReaProject proj, int idx, bool &isrgn, &pos, &rgnend, #name, int &markrgnindexnumber, int &color)
integer retval, boolean isrgn, number pos, number rgnend, string name, integer markrgnindexnumber, integer color = reaper.EnumProjectMarkers3(ReaProject proj, integer idx)
(Int retval, ReaProject proj, Int idx, Boolean isrgnOut, Float posOut, Float rgnendOut, String nameOut, Int markrgnindexnumberOut, Int colorOut) = RPR_EnumProjectMarkers3(proj, idx, isrgnOut, posOut, rgnendOut, nameOut, markrgnindexnumberOut, colorOut)
ReaProject* EnumProjects(int idx, char* projfnOutOptional, int projfnOutOptional_sz)
ReaProject EnumProjects(int idx, optional #projfn)
ReaProject retval, optional string projfn = reaper.EnumProjects(integer idx)
(ReaProject retval, Int idx, String projfnOutOptional, Int projfnOutOptional_sz) = RPR_EnumProjects(idx, projfnOutOptional, projfnOutOptional_sz)

idx=-1 for current project,projfn can be NULL if not interested in filename. use idx 0x40000000 for currently rendering project, if any.

bool EnumProjExtState(ReaProject* proj, const char* extname, int idx, char* keyOutOptional, int keyOutOptional_sz, char* valOutOptional, int valOutOptional_sz)
bool EnumProjExtState(ReaProject proj, "extname", int idx, optional #key, optional #val)
boolean retval, optional string key, optional string val = reaper.EnumProjExtState(ReaProject proj, string extname, integer idx)
(Boolean retval, ReaProject proj, String extname, Int idx, String keyOutOptional, Int keyOutOptional_sz, String valOutOptional, Int valOutOptional_sz) = RPR_EnumProjExtState(proj, extname, idx, keyOutOptional, keyOutOptional_sz, valOutOptional, valOutOptional_sz)

Enumerate the data stored with the project for a specific extname. Returns false when there is no more data. See SetProjExtState, GetProjExtState.

MediaTrack* EnumRegionRenderMatrix(ReaProject* proj, int regionindex, int rendertrack)
MediaTrack EnumRegionRenderMatrix(ReaProject proj, int regionindex, int rendertrack)
MediaTrack reaper.EnumRegionRenderMatrix(ReaProject proj, integer regionindex, integer rendertrack)
MediaTrack RPR_EnumRegionRenderMatrix(ReaProject proj, Int regionindex, Int rendertrack)

Enumerate which tracks will be rendered within this region when using the region render matrix. When called with rendertrack==0, the function returns the first track that will be rendered (which may be the master track); rendertrack==1 will return the next track rendered, and so on. The function returns NULL when there are no more tracks that will be rendered within this region.

bool EnumTrackMIDIProgramNames(int track, int programNumber, char* programName, int programName_sz)
bool EnumTrackMIDIProgramNames(int track, int programNumber, #programName)
boolean retval, string programName = reaper.EnumTrackMIDIProgramNames(integer track, integer programNumber, string programName)
(Boolean retval, Int track, Int programNumber, String programName, Int programName_sz) = RPR_EnumTrackMIDIProgramNames(track, programNumber, programName, programName_sz)

returns false if there are no plugins on the track that support MIDI programs,or if all programs have been enumerated

bool EnumTrackMIDIProgramNamesEx(ReaProject* proj, MediaTrack* track, int programNumber, char* programName, int programName_sz)
bool EnumTrackMIDIProgramNamesEx(ReaProject proj, MediaTrack track, int programNumber, #programName)
boolean retval, string programName = reaper.EnumTrackMIDIProgramNamesEx(ReaProject proj, MediaTrack track, integer programNumber, string programName)
(Boolean retval, ReaProject proj, MediaTrack track, Int programNumber, String programName, Int programName_sz) = RPR_EnumTrackMIDIProgramNamesEx(proj, track, programNumber, programName, programName_sz)

returns false if there are no plugins on the track that support MIDI programs,or if all programs have been enumerated

int Envelope_Evaluate(TrackEnvelope* envelope, double time, double samplerate, int samplesRequested, double* valueOut, double* dVdSOut, double* ddVdSOut, double* dddVdSOut)
int Envelope_Evaluate(TrackEnvelope envelope, time, samplerate, int samplesRequested, &value, &dVdS, &ddVdS, &dddVdS)
integer retval, number value, number dVdS, number ddVdS, number dddVdS = reaper.Envelope_Evaluate(TrackEnvelope envelope, number time, number samplerate, integer samplesRequested)
(Int retval, TrackEnvelope envelope, Float time, Float samplerate, Int samplesRequested, Float valueOut, Float dVdSOut, Float ddVdSOut, Float dddVdSOut) = RPR_Envelope_Evaluate(envelope, time, samplerate, samplesRequested, valueOut, dVdSOut, ddVdSOut, dddVdSOut)

Get the effective envelope value at a given time position. samplesRequested is how long the caller expects until the next call to Envelope_Evaluate (often, the buffer block size). The return value is how many samples beyond that time position that the returned values are valid. dVdS is the change in value per sample (first derivative), ddVdS is the second derivative, dddVdS is the third derivative. See GetEnvelopeScalingMode.

void Envelope_FormatValue(TrackEnvelope* env, double value, char* bufOut, int bufOut_sz)
Envelope_FormatValue(TrackEnvelope env, value, #buf)
string buf = reaper.Envelope_FormatValue(TrackEnvelope env, number value)
(TrackEnvelope env, Float value, String bufOut, Int bufOut_sz) = RPR_Envelope_FormatValue(env, value, bufOut, bufOut_sz)

Formats the value of an envelope to a user-readable form

MediaItem_Take* Envelope_GetParentTake(TrackEnvelope* env, int* indexOut, int* index2Out)
MediaItem_Take Envelope_GetParentTake(TrackEnvelope env, int &index, int &index2)
MediaItem_Take retval, integer index, integer index2 = reaper.Envelope_GetParentTake(TrackEnvelope env)
(MediaItem_Take retval, TrackEnvelope env, Int indexOut, Int index2Out) = RPR_Envelope_GetParentTake(env, indexOut, index2Out)

If take envelope, gets the take from the envelope. If FX, indexOut set to FX index, index2Out set to parameter index, otherwise -1.

MediaTrack* Envelope_GetParentTrack(TrackEnvelope* env, int* indexOut, int* index2Out)
MediaTrack Envelope_GetParentTrack(TrackEnvelope env, int &index, int &index2)
MediaTrack retval, integer index, integer index2 = reaper.Envelope_GetParentTrack(TrackEnvelope env)
(MediaTrack retval, TrackEnvelope env, Int indexOut, Int index2Out) = RPR_Envelope_GetParentTrack(env, indexOut, index2Out)

If track envelope, gets the track from the envelope. If FX, indexOut set to FX index, index2Out set to parameter index, otherwise -1.

bool Envelope_SortPoints(TrackEnvelope* envelope)
bool Envelope_SortPoints(TrackEnvelope envelope)
boolean reaper.Envelope_SortPoints(TrackEnvelope envelope)
Boolean RPR_Envelope_SortPoints(TrackEnvelope envelope)

Sort envelope points by time. See SetEnvelopePoint, InsertEnvelopePoint.

bool Envelope_SortPointsEx(TrackEnvelope* envelope, int autoitem_idx)
bool Envelope_SortPointsEx(TrackEnvelope envelope, int autoitem_idx)
boolean reaper.Envelope_SortPointsEx(TrackEnvelope envelope, integer autoitem_idx)
Boolean RPR_Envelope_SortPointsEx(TrackEnvelope envelope, Int autoitem_idx)

Sort envelope points by time. autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc. See SetEnvelopePoint, InsertEnvelopePoint.

const char* ExecProcess(const char* cmdline, int timeoutmsec)
bool ExecProcess(#retval, "cmdline", int timeoutmsec)
string reaper.ExecProcess(string cmdline, integer timeoutmsec)
String RPR_ExecProcess(String cmdline, Int timeoutmsec)

Executes command line, returns NULL on total failure, otherwise the return value, a newline, and then the output of the command. If timeoutmsec is 0, command will be allowed to run indefinitely (recommended for large amounts of returned output). timeoutmsec is -1 for no wait/terminate, -2 for no wait and minimize

bool file_exists(const char* path)
bool file_exists("path")
boolean reaper.file_exists(string path)
Boolean RPR_file_exists(String path)

returns true if path points to a valid, readable file

int FindTempoTimeSigMarker(ReaProject* project, double time)
int FindTempoTimeSigMarker(ReaProject project, time)
integer reaper.FindTempoTimeSigMarker(ReaProject project, number time)
Int RPR_FindTempoTimeSigMarker(ReaProject project, Float time)

Find the tempo/time signature marker that falls at or before this time position (the marker that is in effect as of this time position).

void format_timestr(double tpos, char* buf, int buf_sz)
format_timestr(tpos, #buf)
string buf = reaper.format_timestr(number tpos, string buf)
(Float tpos, String buf, Int buf_sz) = RPR_format_timestr(tpos, buf, buf_sz)

Format tpos (which is time in seconds) as hh:mm:ss.sss. See format_timestr_pos, format_timestr_len.

void format_timestr_len(double tpos, char* buf, int buf_sz, double offset, int modeoverride)
format_timestr_len(tpos, #buf, offset, int modeoverride)
string buf = reaper.format_timestr_len(number tpos, string buf, number offset, integer modeoverride)
(Float tpos, String buf, Int buf_sz, Float offset, Int modeoverride) = RPR_format_timestr_len(tpos, buf, buf_sz, offset, modeoverride)

time formatting mode overrides: -1=proj default.
0=time
1=measures.beats + time
2=measures.beats
3=seconds
4=samples
5=h:m:s:f
offset is start of where the length will be calculated from

void format_timestr_pos(double tpos, char* buf, int buf_sz, int modeoverride)
format_timestr_pos(tpos, #buf, int modeoverride)
string buf = reaper.format_timestr_pos(number tpos, string buf, integer modeoverride)
(Float tpos, String buf, Int buf_sz, Int modeoverride) = RPR_format_timestr_pos(tpos, buf, buf_sz, modeoverride)

time formatting mode overrides: -1=proj default.
0=time
1=measures.beats + time
2=measures.beats
3=seconds
4=samples
5=h:m:s:f

void genGuid(GUID* g)
genGuid(#gGUID)
string gGUID = reaper.genGuid(string gGUID)
RPR_genGuid(GUID g)
bool get_config_var_string(const char* name, char* bufOut, int bufOut_sz)
bool get_config_var_string("name", #buf)
boolean retval, string buf = reaper.get_config_var_string(string name)
(Boolean retval, String name, String bufOut, Int bufOut_sz) = RPR_get_config_var_string(name, bufOut, bufOut_sz)

gets ini configuration variable value as string

const char* get_ini_file()
bool get_ini_file(#retval)
string reaper.get_ini_file()
String RPR_get_ini_file()

Get reaper.ini full filename.

bool GetActionShortcutDesc(KbdSectionInfo* section, int cmdID, int shortcutidx, char* descOut, int descOut_sz)
bool GetActionShortcutDesc(KbdSectionInfo section, int cmdID, int shortcutidx, #desc)
boolean retval, string desc = reaper.GetActionShortcutDesc(KbdSectionInfo section, integer cmdID, integer shortcutidx)
(Boolean retval, KbdSectionInfo section, Int cmdID, Int shortcutidx, String descOut, Int descOut_sz) = RPR_GetActionShortcutDesc(section, cmdID, shortcutidx, descOut, descOut_sz)

Get the text description of a specific shortcut for the given command ID.
See CountActionShortcuts,DeleteActionShortcut,DoActionShortcutDialog.

MediaItem_Take* GetActiveTake(MediaItem* item)
MediaItem_Take GetActiveTake(MediaItem item)
MediaItem_Take reaper.GetActiveTake(MediaItem item)
MediaItem_Take RPR_GetActiveTake(MediaItem item)

get the active take in this item

int GetAllProjectPlayStates(ReaProject* ignoreProject)
int GetAllProjectPlayStates(ReaProject ignoreProject)
integer reaper.GetAllProjectPlayStates(ReaProject ignoreProject)
Int RPR_GetAllProjectPlayStates(ReaProject ignoreProject)

returns the bitwise OR of all project play states (1=playing, 2=pause, 4=recording)

const char* GetAppVersion()
bool GetAppVersion(#retval)
string reaper.GetAppVersion()
String RPR_GetAppVersion()

Returns app version which may include an OS/arch signifier, such as: "6.17" (windows 32-bit), "6.17/x64" (windows 64-bit), "6.17/OSX64" (macOS 64-bit Intel), "6.17/OSX" (macOS 32-bit), "6.17/macOS-arm64", "6.17/linux-x86_64", "6.17/linux-i686", "6.17/linux-aarch64", "6.17/linux-armv7l", etc

int GetArmedCommand(char* secOut, int secOut_sz)
int GetArmedCommand(#sec)
integer retval, string sec = reaper.GetArmedCommand()
(Int retval, String secOut, Int secOut_sz) = RPR_GetArmedCommand(secOut, secOut_sz)

gets the currently armed command and section name (returns 0 if nothing armed). section name is empty-string for main section.

double GetAudioAccessorEndTime(AudioAccessor* accessor)
double GetAudioAccessorEndTime(AudioAccessor accessor)
number reaper.GetAudioAccessorEndTime(AudioAccessor accessor)
Float RPR_GetAudioAccessorEndTime(AudioAccessor accessor)

Get the end time of the audio that can be returned from this accessor. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorSamples.

void GetAudioAccessorHash(AudioAccessor* accessor, char* hashNeed128)
GetAudioAccessorHash(AudioAccessor accessor, #hashNeed128)
string hashNeed128 = reaper.GetAudioAccessorHash(AudioAccessor accessor, string hashNeed128)
(AudioAccessor accessor, String hashNeed128) = RPR_GetAudioAccessorHash(accessor, hashNeed128)

Deprecated. See AudioAccessorStateChanged instead.

int GetAudioAccessorSamples(AudioAccessor* accessor, int samplerate, int numchannels, double starttime_sec, int numsamplesperchannel, double* samplebuffer)
int GetAudioAccessorSamples(AudioAccessor accessor, int samplerate, int numchannels, starttime_sec, int numsamplesperchannel, buffer_ptr samplebuffer)
integer reaper.GetAudioAccessorSamples(AudioAccessor accessor, integer samplerate, integer numchannels, number starttime_sec, integer numsamplesperchannel, reaper.array samplebuffer)
(Int retval, AudioAccessor accessor, Int samplerate, Int numchannels, Float starttime_sec, Int numsamplesperchannel, Float samplebuffer) = RPR_GetAudioAccessorSamples(accessor, samplerate, numchannels, starttime_sec, numsamplesperchannel, samplebuffer)

Get a block of samples from the audio accessor. Samples are extracted immediately pre-FX, and returned interleaved (first sample of first channel, first sample of second channel...). Returns 0 if no audio, 1 if audio, -1 on error. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime.

This function has special handling in Python, and only returns two objects, the API function return value, and the sample buffer. Example usage:

RPR_GetTrack(0, 0)
aa = RPR_CreateTrackAudioAccessor(tr)
buf = list([0]*2*1024) # 2 channels, 1024 samples each, initialized to zero
pos = 0.0
(ret, buf) = GetAudioAccessorSamples(aa, 44100, 2, pos, 1024, buf)
# buf now holds the first 2*1024 audio samples from the track.
# typically GetAudioAccessorSamples() would be called within a loop, increasing pos each time.

double GetAudioAccessorStartTime(AudioAccessor* accessor)
double GetAudioAccessorStartTime(AudioAccessor accessor)
number reaper.GetAudioAccessorStartTime(AudioAccessor accessor)
Float RPR_GetAudioAccessorStartTime(AudioAccessor accessor)

Get the start time of the audio that can be returned from this accessor. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorEndTime, GetAudioAccessorSamples.

bool GetAudioDeviceInfo(const char* attribute, char* descOut, int descOut_sz)
bool GetAudioDeviceInfo("attribute", #desc)
boolean retval, string desc = reaper.GetAudioDeviceInfo(string attribute)
(Boolean retval, String attribute, String descOut, Int descOut_sz) = RPR_GetAudioDeviceInfo(attribute, descOut, descOut_sz)

get information about the currently open audio device. attribute can be MODE, IDENT_IN, IDENT_OUT, BSIZE, SRATE, BPS. returns false if unknown attribute or device not open.

int GetConfigWantsDock(const char* ident_str)
int GetConfigWantsDock("ident_str")
integer reaper.GetConfigWantsDock(string ident_str)
Int RPR_GetConfigWantsDock(String ident_str)

gets the dock ID desired by ident_str, if any

ReaProject* GetCurrentProjectInLoadSave()
ReaProject GetCurrentProjectInLoadSave()
ReaProject reaper.GetCurrentProjectInLoadSave()
ReaProject RPR_GetCurrentProjectInLoadSave()

returns current project if in load/save (usually only used from project_config_extension_t)

int GetCursorContext()
int GetCursorContext()
integer reaper.GetCursorContext()
Int RPR_GetCursorContext()

return the current cursor context: 0 if track panels, 1 if items, 2 if envelopes, otherwise unknown

int GetCursorContext2(bool want_last_valid)
int GetCursorContext2(bool want_last_valid)
integer reaper.GetCursorContext2(boolean want_last_valid)
Int RPR_GetCursorContext2(Boolean want_last_valid)

0 if track panels, 1 if items, 2 if envelopes, otherwise unknown (unlikely when want_last_valid is true)

double GetCursorPosition()
double GetCursorPosition()
number reaper.GetCursorPosition()
Float RPR_GetCursorPosition()

edit cursor position

double GetCursorPositionEx(ReaProject* proj)
double GetCursorPositionEx(ReaProject proj)
number reaper.GetCursorPositionEx(ReaProject proj)
Float RPR_GetCursorPositionEx(ReaProject proj)

edit cursor position

int GetDisplayedMediaItemColor(MediaItem* item)
int GetDisplayedMediaItemColor(MediaItem item)
integer reaper.GetDisplayedMediaItemColor(MediaItem item)
Int RPR_GetDisplayedMediaItemColor(MediaItem item)

see GetDisplayedMediaItemColor2.

int GetDisplayedMediaItemColor2(MediaItem* item, MediaItem_Take* take)
int GetDisplayedMediaItemColor2(MediaItem item, MediaItem_Take take)
integer reaper.GetDisplayedMediaItemColor2(MediaItem item, MediaItem_Take take)
Int RPR_GetDisplayedMediaItemColor2(MediaItem item, MediaItem_Take take)

Returns the custom take, item, or track color that is used (according to the user preference) to color the media item. The returned color is OS dependent|0x01000000 (i.e. ColorToNative(r,g,b)|0x01000000), so a return of zero means "no color", not black.

double GetEnvelopeInfo_Value(TrackEnvelope* env, const char* parmname)
double GetEnvelopeInfo_Value(TrackEnvelope env, "parmname")
number reaper.GetEnvelopeInfo_Value(TrackEnvelope env, string parmname)
Float RPR_GetEnvelopeInfo_Value(TrackEnvelope env, String parmname)

Gets an envelope numerical-value attribute:
I_TCPY : int : Y offset of envelope relative to parent track (may be separate lane or overlap with track contents)
I_TCPH : int : visible height of envelope
I_TCPY_USED : int : Y offset of envelope relative to parent track, exclusive of padding
I_TCPH_USED : int : visible height of envelope, exclusive of padding
P_TRACK : MediaTrack * : parent track pointer (if any)
P_DESTTRACK : MediaTrack * : destination track pointer, if on a send
P_ITEM : MediaItem * : parent item pointer (if any)
P_TAKE : MediaItem_Take * : parent take pointer (if any)
I_SEND_IDX : int : 1-based index of send in P_TRACK, or 0 if not a send
I_HWOUT_IDX : int : 1-based index of hardware output in P_TRACK or 0 if not a hardware output
I_RECV_IDX : int : 1-based index of receive in P_DESTTRACK or 0 if not a send/receive

bool GetEnvelopeName(TrackEnvelope* env, char* bufOut, int bufOut_sz)
bool GetEnvelopeName(TrackEnvelope env, #buf)
boolean retval, string buf = reaper.GetEnvelopeName(TrackEnvelope env)
(Boolean retval, TrackEnvelope env, String bufOut, Int bufOut_sz) = RPR_GetEnvelopeName(env, bufOut, bufOut_sz)
bool GetEnvelopePoint(TrackEnvelope* envelope, int ptidx, double* timeOut, double* valueOut, int* shapeOut, double* tensionOut, bool* selectedOut)
bool GetEnvelopePoint(TrackEnvelope envelope, int ptidx, &time, &value, int &shape, &tension, bool &selected)
boolean retval, number time, number value, integer shape, number tension, boolean selected = reaper.GetEnvelopePoint(TrackEnvelope envelope, integer ptidx)
(Boolean retval, TrackEnvelope envelope, Int ptidx, Float timeOut, Float valueOut, Int shapeOut, Float tensionOut, Boolean selectedOut) = RPR_GetEnvelopePoint(envelope, ptidx, timeOut, valueOut, shapeOut, tensionOut, selectedOut)

Get the attributes of an envelope point. See GetEnvelopePointEx.

int GetEnvelopePointByTime(TrackEnvelope* envelope, double time)
int GetEnvelopePointByTime(TrackEnvelope envelope, time)
integer reaper.GetEnvelopePointByTime(TrackEnvelope envelope, number time)
Int RPR_GetEnvelopePointByTime(TrackEnvelope envelope, Float time)

Returns the envelope point at or immediately prior to the given time position. See GetEnvelopePointByTimeEx.

int GetEnvelopePointByTimeEx(TrackEnvelope* envelope, int autoitem_idx, double time)
int GetEnvelopePointByTimeEx(TrackEnvelope envelope, int autoitem_idx, time)
integer reaper.GetEnvelopePointByTimeEx(TrackEnvelope envelope, integer autoitem_idx, number time)
Int RPR_GetEnvelopePointByTimeEx(TrackEnvelope envelope, Int autoitem_idx, Float time)

Returns the envelope point at or immediately prior to the given time position.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See GetEnvelopePointEx, SetEnvelopePointEx, InsertEnvelopePointEx, DeleteEnvelopePointEx.

bool GetEnvelopePointEx(TrackEnvelope* envelope, int autoitem_idx, int ptidx, double* timeOut, double* valueOut, int* shapeOut, double* tensionOut, bool* selectedOut)
bool GetEnvelopePointEx(TrackEnvelope envelope, int autoitem_idx, int ptidx, &time, &value, int &shape, &tension, bool &selected)
boolean retval, number time, number value, integer shape, number tension, boolean selected = reaper.GetEnvelopePointEx(TrackEnvelope envelope, integer autoitem_idx, integer ptidx)
(Boolean retval, TrackEnvelope envelope, Int autoitem_idx, Int ptidx, Float timeOut, Float valueOut, Int shapeOut, Float tensionOut, Boolean selectedOut) = RPR_GetEnvelopePointEx(envelope, autoitem_idx, ptidx, timeOut, valueOut, shapeOut, tensionOut, selectedOut)

Get the attributes of an envelope point.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See CountEnvelopePointsEx, SetEnvelopePointEx, InsertEnvelopePointEx, DeleteEnvelopePointEx.

int GetEnvelopeScalingMode(TrackEnvelope* env)
int GetEnvelopeScalingMode(TrackEnvelope env)
integer reaper.GetEnvelopeScalingMode(TrackEnvelope env)
Int RPR_GetEnvelopeScalingMode(TrackEnvelope env)

Returns the envelope scaling mode: 0=no scaling, 1=fader scaling. All API functions deal with raw envelope point values, to convert raw from/to scaled values see ScaleFromEnvelopeMode, ScaleToEnvelopeMode.

bool GetEnvelopeStateChunk(TrackEnvelope* env, char* strNeedBig, int strNeedBig_sz, bool isundoOptional)
bool GetEnvelopeStateChunk(TrackEnvelope env, #str, bool isundo)
boolean retval, string str = reaper.GetEnvelopeStateChunk(TrackEnvelope env, string str, boolean isundo)
(Boolean retval, TrackEnvelope env, String strNeedBig, Int strNeedBig_sz, Boolean isundoOptional) = RPR_GetEnvelopeStateChunk(env, strNeedBig, strNeedBig_sz, isundoOptional)

Gets the RPPXML state of an envelope, returns true if successful. Undo flag is a performance/caching hint.

int GetEnvelopeUIState(TrackEnvelope* env)
int GetEnvelopeUIState(TrackEnvelope env)
integer reaper.GetEnvelopeUIState(TrackEnvelope env)
Int RPR_GetEnvelopeUIState(TrackEnvelope env)

gets information on the UI state of an envelope: returns &1 if automation/modulation is playing back, &2 if automation is being actively written, &4 if the envelope recently had an effective automation mode change

const char* GetExePath()
bool GetExePath(#retval)
string reaper.GetExePath()
String RPR_GetExePath()

returns path of REAPER.exe (not including EXE), i.e. C:\Program Files\REAPER

const char* GetExtState(const char* section, const char* key)
bool GetExtState(#retval, "section", "key")
string reaper.GetExtState(string section, string key)
String RPR_GetExtState(String section, String key)

Get the extended state value for a specific section and key. See SetExtState, DeleteExtState, HasExtState.

int GetFocusedFX(int* tracknumberOut, int* itemnumberOut, int* fxnumberOut)
int GetFocusedFX(int &tracknumber, int &itemnumber, int &fxnumber)
integer retval, integer tracknumber, integer itemnumber, integer fxnumber = reaper.GetFocusedFX()
(Int retval, Int tracknumberOut, Int itemnumberOut, Int fxnumberOut) = RPR_GetFocusedFX(tracknumberOut, itemnumberOut, fxnumberOut)

This function is deprecated (returns GetFocusedFX2()&3), see GetTouchedOrFocusedFX.

int GetFocusedFX2(int* tracknumberOut, int* itemnumberOut, int* fxnumberOut)
int GetFocusedFX2(int &tracknumber, int &itemnumber, int &fxnumber)
integer retval, integer tracknumber, integer itemnumber, integer fxnumber = reaper.GetFocusedFX2()
(Int retval, Int tracknumberOut, Int itemnumberOut, Int fxnumberOut) = RPR_GetFocusedFX2(tracknumberOut, itemnumberOut, fxnumberOut)

Return value has 1 set if track FX, 2 if take/item FX, 4 set if FX is no longer focused but still open. tracknumber==0 means the master track, 1 means track 1, etc. itemnumber is zero-based (or -1 if not an item). For interpretation of fxnumber, see GetLastTouchedFX. Deprecated, see GetTouchedOrFocusedFX

int GetFreeDiskSpaceForRecordPath(ReaProject* proj, int pathidx)
int GetFreeDiskSpaceForRecordPath(ReaProject proj, int pathidx)
integer reaper.GetFreeDiskSpaceForRecordPath(ReaProject proj, integer pathidx)
Int RPR_GetFreeDiskSpaceForRecordPath(ReaProject proj, Int pathidx)

returns free disk space in megabytes, pathIdx 0 for normal, 1 for alternate.

TrackEnvelope* GetFXEnvelope(MediaTrack* track, int fxindex, int parameterindex, bool create)
TrackEnvelope GetFXEnvelope(MediaTrack track, int fxindex, int parameterindex, bool create)
TrackEnvelope reaper.GetFXEnvelope(MediaTrack track, integer fxindex, integer parameterindex, boolean create)
TrackEnvelope RPR_GetFXEnvelope(MediaTrack track, Int fxindex, Int parameterindex, Boolean create)

Returns the FX parameter envelope. If the envelope does not exist and create=true, the envelope will be created. If the envelope already exists and is bypassed and create=true, then the envelope will be unbypassed.

int GetGlobalAutomationOverride()
int GetGlobalAutomationOverride()
integer reaper.GetGlobalAutomationOverride()
Int RPR_GetGlobalAutomationOverride()

return -1=no override, 0=trim/read, 1=read, 2=touch, 3=write, 4=latch, 5=bypass

double GetHZoomLevel()
double GetHZoomLevel()
number reaper.GetHZoomLevel()
Float RPR_GetHZoomLevel()

returns pixels/second

double GetInputActivityLevel(int input_id)
double GetInputActivityLevel(int input_id)
number reaper.GetInputActivityLevel(integer input_id)
Float RPR_GetInputActivityLevel(Int input_id)

returns approximate input level if available, 0-511 mono inputs, |1024 for stereo pairs, 4096+devidx*32 for MIDI devices

const char* GetInputChannelName(int channelIndex)
bool GetInputChannelName(#retval, int channelIndex)
string reaper.GetInputChannelName(integer channelIndex)
String RPR_GetInputChannelName(Int channelIndex)
void GetInputOutputLatency(int* inputlatencyOut, int* outputLatencyOut)
GetInputOutputLatency(int &inputlatency, int &outputLatency)
integer inputlatency, integer outputLatency = reaper.GetInputOutputLatency()
(Int inputlatencyOut, Int outputLatencyOut) = RPR_GetInputOutputLatency(inputlatencyOut, outputLatencyOut)

Gets the audio device input/output latency in samples

double GetItemEditingTime2(PCM_source** which_itemOut, int* flagsOut)
double GetItemEditingTime2(PCM_source &which_item, int &flags)
number, PCM_source which_item, integer flags = reaper.GetItemEditingTime2()
(Float retval, PCM_source* which_itemOut, Int flagsOut) = RPR_GetItemEditingTime2(which_itemOut, flagsOut)

returns time of relevant edit, set which_item to the pcm_source (if applicable), flags (if specified) will be set to 1 for edge resizing, 2 for fade change, 4 for item move, 8 for item slip edit (edit cursor time or start of item)

MediaItem* GetItemFromPoint(int screen_x, int screen_y, bool allow_locked, MediaItem_Take** takeOutOptional)
MediaItem GetItemFromPoint(int screen_x, int screen_y, bool allow_locked, MediaItem_Take &take)
MediaItem, MediaItem_Take take = reaper.GetItemFromPoint(integer screen_x, integer screen_y, boolean allow_locked)
MediaItem RPR_GetItemFromPoint(Int screen_x, Int screen_y, Boolean allow_locked, MediaItem_Take* takeOutOptional)

Returns the first item at the screen coordinates specified. If allow_locked is false, locked items are ignored. If takeOutOptional specified, returns the take hit. See GetThingFromPoint.

ReaProject* GetItemProjectContext(MediaItem* item)
ReaProject GetItemProjectContext(MediaItem item)
ReaProject reaper.GetItemProjectContext(MediaItem item)
ReaProject RPR_GetItemProjectContext(MediaItem item)
bool GetItemStateChunk(MediaItem* item, char* strNeedBig, int strNeedBig_sz, bool isundoOptional)
bool GetItemStateChunk(MediaItem item, #str, bool isundo)
boolean retval, string str = reaper.GetItemStateChunk(MediaItem item, string str, boolean isundo)
(Boolean retval, MediaItem item, String strNeedBig, Int strNeedBig_sz, Boolean isundoOptional) = RPR_GetItemStateChunk(item, strNeedBig, strNeedBig_sz, isundoOptional)

Gets the RPPXML state of an item, returns true if successful. Undo flag is a performance/caching hint.

const char* GetLastColorThemeFile()
bool GetLastColorThemeFile(#retval)
string reaper.GetLastColorThemeFile()
String RPR_GetLastColorThemeFile()
void GetLastMarkerAndCurRegion(ReaProject* proj, double time, int* markeridxOut, int* regionidxOut)
GetLastMarkerAndCurRegion(ReaProject proj, time, int &markeridx, int &regionidx)
integer markeridx, integer regionidx = reaper.GetLastMarkerAndCurRegion(ReaProject proj, number time)
(ReaProject proj, Float time, Int markeridxOut, Int regionidxOut) = RPR_GetLastMarkerAndCurRegion(proj, time, markeridxOut, regionidxOut)

Get the last project marker before time, and/or the project region that includes time. markeridx and regionidx are returned not necessarily as the displayed marker/region index, but as the index that can be passed to EnumProjectMarkers. Either or both of markeridx and regionidx may be NULL. See EnumProjectMarkers.

bool GetLastTouchedFX(int* tracknumberOut, int* fxnumberOut, int* paramnumberOut)
bool GetLastTouchedFX(int &tracknumber, int &fxnumber, int &paramnumber)
boolean retval, integer tracknumber, integer fxnumber, integer paramnumber = reaper.GetLastTouchedFX()
(Boolean retval, Int tracknumberOut, Int fxnumberOut, Int paramnumberOut) = RPR_GetLastTouchedFX(tracknumberOut, fxnumberOut, paramnumberOut)

Returns true if the last touched FX parameter is valid, false otherwise. The low word of tracknumber is the 1-based track index -- 0 means the master track, 1 means track 1, etc. If the high word of tracknumber is nonzero, it refers to the 1-based item index (1 is the first item on the track, etc). For track FX, the low 24 bits of fxnumber refer to the FX index in the chain, and if the next 8 bits are 01, then the FX is record FX. For item FX, the low word defines the FX index in the chain, and the high word defines the take number. Deprecated, see GetTouchedOrFocusedFX.

MediaTrack* GetLastTouchedTrack()
MediaTrack GetLastTouchedTrack()
MediaTrack reaper.GetLastTouchedTrack()
MediaTrack RPR_GetLastTouchedTrack()
HWND GetMainHwnd()
HWND GetMainHwnd()
HWND reaper.GetMainHwnd()
HWND RPR_GetMainHwnd()
int GetMasterMuteSoloFlags()
int GetMasterMuteSoloFlags()
integer reaper.GetMasterMuteSoloFlags()
Int RPR_GetMasterMuteSoloFlags()

&1=master mute,&2=master solo. This is deprecated as you can just query the master track as well.

MediaTrack* GetMasterTrack(ReaProject* proj)
MediaTrack GetMasterTrack(ReaProject proj)
MediaTrack reaper.GetMasterTrack(ReaProject proj)
MediaTrack RPR_GetMasterTrack(ReaProject proj)
int GetMasterTrackVisibility()
int GetMasterTrackVisibility()
integer reaper.GetMasterTrackVisibility()
Int RPR_GetMasterTrackVisibility()

returns &1 if the master track is visible in the TCP, &2 if NOT visible in the mixer. See SetMasterTrackVisibility.

int GetMaxMidiInputs()
int GetMaxMidiInputs()
integer reaper.GetMaxMidiInputs()
Int RPR_GetMaxMidiInputs()

returns max dev for midi inputs/outputs

int GetMaxMidiOutputs()
int GetMaxMidiOutputs()
integer reaper.GetMaxMidiOutputs()
Int RPR_GetMaxMidiOutputs()
int GetMediaFileMetadata(PCM_source* mediaSource, const char* identifier, char* bufOutNeedBig, int bufOutNeedBig_sz)
int GetMediaFileMetadata(PCM_source mediaSource, "identifier", #buf)
integer retval, string buf = reaper.GetMediaFileMetadata(PCM_source mediaSource, string identifier)
(Int retval, PCM_source mediaSource, String identifier, String bufOutNeedBig, Int bufOutNeedBig_sz) = RPR_GetMediaFileMetadata(mediaSource, identifier, bufOutNeedBig, bufOutNeedBig_sz)

Get text-based metadata from a media file for a given identifier. Call with identifier="" to list all identifiers contained in the file, separated by newlines. May return "[Binary data]" for metadata that REAPER doesn't handle.

MediaItem* GetMediaItem(ReaProject* proj, int itemidx)
MediaItem GetMediaItem(ReaProject proj, int itemidx)
MediaItem reaper.GetMediaItem(ReaProject proj, integer itemidx)
MediaItem RPR_GetMediaItem(ReaProject proj, Int itemidx)

get an item from a project by item count (zero-based) (proj=0 for active project)

MediaTrack* GetMediaItem_Track(MediaItem* item)
MediaTrack GetMediaItem_Track(MediaItem item)
MediaTrack reaper.GetMediaItem_Track(MediaItem item)
MediaTrack RPR_GetMediaItem_Track(MediaItem item)

Get parent track of media item

double GetMediaItemInfo_Value(MediaItem* item, const char* parmname)
double GetMediaItemInfo_Value(MediaItem item, "parmname")
number reaper.GetMediaItemInfo_Value(MediaItem item, string parmname)
Float RPR_GetMediaItemInfo_Value(MediaItem item, String parmname)

Get media item numerical-value attributes.
B_MUTE : bool * : muted (item solo overrides). setting this value will clear C_MUTE_SOLO.
B_MUTE_ACTUAL : bool * : muted (ignores solo). setting this value will not affect C_MUTE_SOLO.
C_LANEPLAYS : char * : in fixed lane tracks, 0=this item lane does not play, 1=this item lane plays exclusively, 2=this item lane plays and other lanes also play, -1=this item is on a non-visible, non-playing lane on a non-fixed-lane track (read-only)
C_MUTE_SOLO : char * : solo override (-1=soloed, 0=no override, 1=unsoloed). note that this API does not automatically unsolo other items when soloing (nor clear the unsolos when clearing the last soloed item), it must be done by the caller via action or via this API.
B_LOOPSRC : bool * : loop source
B_ALLTAKESPLAY : bool * : all takes play
B_UISEL : bool * : selected in arrange view
C_BEATATTACHMODE : char * : item timebase, -1=track or project default, 1=beats (position, length, rate), 2=beats (position only). for auto-stretch timebase: C_BEATATTACHMODE=1, C_AUTOSTRETCH=1
C_AUTOSTRETCH: : char * : auto-stretch at project tempo changes, 1=enabled, requires C_BEATATTACHMODE=1
C_LOCK : char * : locked, &1=locked
D_VOL : double * : item volume, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc
D_POSITION : double * : item position in seconds
D_LENGTH : double * : item length in seconds
D_SNAPOFFSET : double * : item snap offset in seconds
D_FADEINLEN : double * : item manual fadein length in seconds
D_FADEOUTLEN : double * : item manual fadeout length in seconds
D_FADEINDIR : double * : item fadein curvature, -1..1
D_FADEOUTDIR : double * : item fadeout curvature, -1..1
D_FADEINLEN_AUTO : double * : item auto-fadein length in seconds, -1=no auto-fadein
D_FADEOUTLEN_AUTO : double * : item auto-fadeout length in seconds, -1=no auto-fadeout
C_FADEINSHAPE : int * : fadein shape, 0..6, 0=linear
C_FADEOUTSHAPE : int * : fadeout shape, 0..6, 0=linear
I_GROUPID : int * : group ID, 0=no group
I_LASTY : int * : Y-position (relative to top of track) in pixels (read-only)
I_LASTH : int * : height in pixels (read-only)
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
I_CURTAKE : int * : active take number
IP_ITEMNUMBER : int : item number on this track (read-only, returns the item number directly)
F_FREEMODE_Y : float * : free item positioning or fixed lane Y-position. 0=top of track, 1.0=bottom of track
F_FREEMODE_H : float * : free item positioning or fixed lane height. 0.5=half the track height, 1.0=full track height
I_FIXEDLANE : int * : fixed lane of item (fine to call with setNewValue, but returned value is read-only)
B_FIXEDLANE_HIDDEN : bool * : true if displaying only one fixed lane and this item is in a different lane (read-only)
P_TRACK : MediaTrack * : (read-only)

int GetMediaItemNumTakes(MediaItem* item)
int GetMediaItemNumTakes(MediaItem item)
integer reaper.GetMediaItemNumTakes(MediaItem item)
Int RPR_GetMediaItemNumTakes(MediaItem item)
MediaItem_Take* GetMediaItemTake(MediaItem* item, int tk)
MediaItem_Take GetMediaItemTake(MediaItem item, int tk)
MediaItem_Take reaper.GetMediaItemTake(MediaItem item, integer tk)
MediaItem_Take RPR_GetMediaItemTake(MediaItem item, Int tk)
MediaItem* GetMediaItemTake_Item(MediaItem_Take* take)
MediaItem GetMediaItemTake_Item(MediaItem_Take take)
MediaItem reaper.GetMediaItemTake_Item(MediaItem_Take take)
MediaItem RPR_GetMediaItemTake_Item(MediaItem_Take take)

Get parent item of media item take

int GetMediaItemTake_Peaks(MediaItem_Take* take, double peakrate, double starttime, int numchannels, int numsamplesperchannel, int want_extra_type, double* buf)
int GetMediaItemTake_Peaks(MediaItem_Take take, peakrate, starttime, int numchannels, int numsamplesperchannel, int want_extra_type, buffer_ptr buf)
integer reaper.GetMediaItemTake_Peaks(MediaItem_Take take, number peakrate, number starttime, integer numchannels, integer numsamplesperchannel, integer want_extra_type, reaper.array buf)
(Int retval, MediaItem_Take take, Float peakrate, Float starttime, Int numchannels, Int numsamplesperchannel, Int want_extra_type, Float buf) = RPR_GetMediaItemTake_Peaks(take, peakrate, starttime, numchannels, numsamplesperchannel, want_extra_type, buf)

Gets block of peak samples to buf. Note that the peak samples are interleaved, but in two or three blocks (maximums, then minimums, then extra). Return value has 20 bits of returned sample count, then 4 bits of output_mode (0xf00000), then a bit to signify whether extra_type was available (0x1000000). extra_type can be 115 ('s') for spectral information, which will return peak samples as integers with the low 15 bits frequency, next 14 bits tonality.

PCM_source* GetMediaItemTake_Source(MediaItem_Take* take)
PCM_source GetMediaItemTake_Source(MediaItem_Take take)
PCM_source reaper.GetMediaItemTake_Source(MediaItem_Take take)
PCM_source RPR_GetMediaItemTake_Source(MediaItem_Take take)

Get media source of media item take

MediaTrack* GetMediaItemTake_Track(MediaItem_Take* take)
MediaTrack GetMediaItemTake_Track(MediaItem_Take take)
MediaTrack reaper.GetMediaItemTake_Track(MediaItem_Take take)
MediaTrack RPR_GetMediaItemTake_Track(MediaItem_Take take)

Get parent track of media item take

MediaItem_Take* GetMediaItemTakeByGUID(ReaProject* project, const GUID* guid)
MediaItem_Take GetMediaItemTakeByGUID(ReaProject project, "guidGUID")
MediaItem_Take reaper.GetMediaItemTakeByGUID(ReaProject project, string guidGUID)
MediaItem_Take RPR_GetMediaItemTakeByGUID(ReaProject project, const GUID guid)
double GetMediaItemTakeInfo_Value(MediaItem_Take* take, const char* parmname)
double GetMediaItemTakeInfo_Value(MediaItem_Take take, "parmname")
number reaper.GetMediaItemTakeInfo_Value(MediaItem_Take take, string parmname)
Float RPR_GetMediaItemTakeInfo_Value(MediaItem_Take take, String parmname)

Get media item take numerical-value attributes.
D_STARTOFFS : double * : start offset in source media, in seconds
D_VOL : double * : take volume, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc, negative if take polarity is flipped
D_PAN : double * : take pan, -1..1
D_PANLAW : double * : take pan law, -1=default, 0.5=-6dB, 1.0=+0dB, etc
D_PLAYRATE : double * : take playback rate, 0.5=half speed, 1=normal, 2=double speed, etc
D_PITCH : double * : take pitch adjustment in semitones, -12=one octave down, 0=normal, +12=one octave up, etc
B_PPITCH : bool * : preserve pitch when changing playback rate
I_LASTY : int * : Y-position (relative to top of track) in pixels (read-only)
I_LASTH : int * : height in pixels (read-only)
I_CHANMODE : int * : channel mode, 0=normal, 1=reverse stereo, 2=downmix, 3=left, 4=right
I_PITCHMODE : int * : pitch shifter mode, -1=project default, otherwise high 2 bytes=shifter, low 2 bytes=parameter
I_STRETCHFLAGS : int * : stretch marker flags (&7 mask for mode override: 0=default, 1=balanced, 2/3/6=tonal, 4=transient, 5=no pre-echo)
F_STRETCHFADESIZE : float * : stretch marker fade size in seconds (0.0025 default)
I_RECPASSID : int * : record pass ID
I_TAKEFX_NCH : int * : number of internal audio channels for per-take FX to use (OK to call with setNewValue, but the returned value is read-only)
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
IP_TAKENUMBER : int : take number (read-only, returns the take number directly)
P_TRACK : pointer to MediaTrack (read-only)
P_ITEM : pointer to MediaItem (read-only)
P_SOURCE : PCM_source *. Note that if setting this, you should first retrieve the old source, set the new, THEN delete the old.

MediaTrack* GetMediaItemTrack(MediaItem* item)
MediaTrack GetMediaItemTrack(MediaItem item)
MediaTrack reaper.GetMediaItemTrack(MediaItem item)
MediaTrack RPR_GetMediaItemTrack(MediaItem item)
void GetMediaSourceFileName(PCM_source* source, char* filenamebufOut, int filenamebufOut_sz)
GetMediaSourceFileName(PCM_source source, #filenamebuf)
string filenamebuf = reaper.GetMediaSourceFileName(PCM_source source)
(PCM_source source, String filenamebufOut, Int filenamebufOut_sz) = RPR_GetMediaSourceFileName(source, filenamebufOut, filenamebufOut_sz)

Copies the media source filename to filenamebuf. Note that in-project MIDI media sources have no associated filename. See GetMediaSourceParent.

double GetMediaSourceLength(PCM_source* source, bool* lengthIsQNOut)
double GetMediaSourceLength(PCM_source source, bool &lengthIsQN)
number retval, boolean lengthIsQN = reaper.GetMediaSourceLength(PCM_source source)
(Float retval, PCM_source source, Boolean lengthIsQNOut) = RPR_GetMediaSourceLength(source, lengthIsQNOut)

Returns the length of the source media. If the media source is beat-based, the length will be in quarter notes, otherwise it will be in seconds.

int GetMediaSourceNumChannels(PCM_source* source)
int GetMediaSourceNumChannels(PCM_source source)
integer reaper.GetMediaSourceNumChannels(PCM_source source)
Int RPR_GetMediaSourceNumChannels(PCM_source source)

Returns the number of channels in the source media.

PCM_source* GetMediaSourceParent(PCM_source* src)
PCM_source GetMediaSourceParent(PCM_source src)
PCM_source reaper.GetMediaSourceParent(PCM_source src)
PCM_source RPR_GetMediaSourceParent(PCM_source src)

Returns the parent source, or NULL if src is the root source. This can be used to retrieve the parent properties of sections or reversed sources for example.

int GetMediaSourceSampleRate(PCM_source* source)
int GetMediaSourceSampleRate(PCM_source source)
integer reaper.GetMediaSourceSampleRate(PCM_source source)
Int RPR_GetMediaSourceSampleRate(PCM_source source)

Returns the sample rate. MIDI source media will return zero.

void GetMediaSourceType(PCM_source* source, char* typebufOut, int typebufOut_sz)
GetMediaSourceType(PCM_source source, #typebuf)
string typebuf = reaper.GetMediaSourceType(PCM_source source)
(PCM_source source, String typebufOut, Int typebufOut_sz) = RPR_GetMediaSourceType(source, typebufOut, typebufOut_sz)

copies the media source type ("WAV", "MIDI", etc) to typebuf

double GetMediaTrackInfo_Value(MediaTrack* tr, const char* parmname)
double GetMediaTrackInfo_Value(MediaTrack tr, "parmname")
number reaper.GetMediaTrackInfo_Value(MediaTrack tr, string parmname)
Float RPR_GetMediaTrackInfo_Value(MediaTrack tr, String parmname)

Get track numerical-value attributes.
B_MUTE : bool * : muted
B_PHASE : bool * : track phase inverted
B_RECMON_IN_EFFECT : bool * : record monitoring in effect (current audio-thread playback state, read-only)
IP_TRACKNUMBER : int : track number 1-based, 0=not found, -1=master track (read-only, returns the int directly)
I_SOLO : int * : soloed, 0=not soloed, 1=soloed, 2=soloed in place, 5=safe soloed, 6=safe soloed in place
B_SOLO_DEFEAT : bool * : when set, if anything else is soloed and this track is not muted, this track acts soloed
I_FXEN : int * : fx enabled, 0=bypassed, !0=fx active
I_RECARM : int * : record armed, 0=not record armed, 1=record armed
I_RECINPUT : int * : record input, <0=no input. if 4096 set, input is MIDI and low 5 bits represent channel (0=all, 1-16=only chan), next 6 bits represent physical input (63=all, 62=VKB). If 4096 is not set, low 10 bits (0..1023) are input start channel (ReaRoute/Loopback start at 512). If 2048 is set, input is multichannel input (using track channel count), or if 1024 is set, input is stereo input, otherwise input is mono.
I_RECMODE : int * : record mode, 0=input, 1=stereo out, 2=none, 3=stereo out w/latency compensation, 4=midi output, 5=mono out, 6=mono out w/ latency compensation, 7=midi overdub, 8=midi replace
I_RECMODE_FLAGS : int * : record mode flags, &3=output recording mode (0=post fader, 1=pre-fx, 2=post-fx/pre-fader)
I_RECMON : int * : record monitoring, 0=off, 1=normal, 2=not when playing (tape style)
I_RECMONITEMS : int * : monitor items while recording, 0=off, 1=on
B_AUTO_RECARM : bool * : automatically set record arm when selected (does not immediately affect recarm state, script should set directly if desired)
I_VUMODE : int * : track vu mode, &1:disabled, &30==0:stereo peaks, &30==2:multichannel peaks, &30==4:stereo RMS, &30==8:combined RMS, &30==12:LUFS-M, &30==16:LUFS-S (readout=max), &30==20:LUFS-S (readout=current), &32:LUFS calculation on channels 1+2 only
I_AUTOMODE : int * : track automation mode, 0=trim/off, 1=read, 2=touch, 3=write, 4=latch
I_NCHAN : int * : number of track channels, 2-128, even numbers only
I_SELECTED : int * : track selected, 0=unselected, 1=selected
I_WNDH : int * : current TCP window height in pixels including envelopes (read-only)
I_TCPH : int * : current TCP window height in pixels not including envelopes (read-only)
I_TCPY : int * : current TCP window Y-position in pixels relative to top of arrange view (read-only)
I_MCPX : int * : current MCP X-position in pixels relative to mixer container (read-only)
I_MCPY : int * : current MCP Y-position in pixels relative to mixer container (read-only)
I_MCPW : int * : current MCP width in pixels (read-only)
I_MCPH : int * : current MCP height in pixels (read-only)
I_FOLDERDEPTH : int * : folder depth change, 0=normal, 1=track is a folder parent, -1=track is the last in the innermost folder, -2=track is the last in the innermost and next-innermost folders, etc
I_FOLDERCOMPACT : int * : folder collapsed state (only valid on folders), 0=normal, 1=collapsed, 2=fully collapsed
I_MIDIHWOUT : int * : track midi hardware output index, <0=disabled, low 5 bits are which channels (0=all, 1-16), next 5 bits are output device index (0-31)
I_PERFFLAGS : int * : track performance flags, &1=no media buffering, &2=no anticipative FX
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
I_HEIGHTOVERRIDE : int * : custom height override for TCP window, 0 for none, otherwise size in pixels
I_SPACER : int * : 1=TCP track spacer above this trackB_HEIGHTLOCK : bool * : track height lock (must set I_HEIGHTOVERRIDE before locking)
D_VOL : double * : trim volume of track, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc
D_PAN : double * : trim pan of track, -1..1
D_WIDTH : double * : width of track, -1..1
D_DUALPANL : double * : dualpan position 1, -1..1, only if I_PANMODE==6
D_DUALPANR : double * : dualpan position 2, -1..1, only if I_PANMODE==6
I_PANMODE : int * : pan mode, 0=classic 3.x, 3=new balance, 5=stereo pan, 6=dual pan
D_PANLAW : double * : pan law of track, <0=project default, 0.5=-6dB, 0.707..=-3dB, 1=+0dB, 1.414..=-3dB with gain compensation, 2=-6dB with gain compensation, etc
I_PANLAW_FLAGS : int * : pan law flags, 0=sine taper, 1=hybrid taper with deprecated behavior when gain compensation enabled, 2=linear taper, 3=hybrid taper
P_ENV:<envchunkname or P_ENV:{GUID... : TrackEnvelope * : (read-only) chunkname can be <VOLENV, <PANENV, etc; GUID is the stringified envelope GUID.
B_SHOWINMIXER : bool * : track control panel visible in mixer (do not use on master track)
B_SHOWINTCP : bool * : track control panel visible in arrange view (do not use on master track)
B_MAINSEND : bool * : track sends audio to parent
C_MAINSEND_OFFS : char * : channel offset of track send to parent
C_MAINSEND_NCH : char * : channel count of track send to parent (0=use all child track channels, 1=use one channel only)
I_FREEMODE : int * : 1=track free item positioning enabled, 2=track fixed lanes enabled (call UpdateTimeline() after changing)
I_NUMFIXEDLANES : int * : number of track fixed lanes (fine to call with setNewValue, but returned value is read-only)
C_LANESCOLLAPSED : char * : fixed lane collapse state (1=lanes collapsed, 2=track displays as non-fixed-lanes but hidden lanes exist)
C_LANEPLAYS:N : char * : on fixed lane tracks, 0=lane N does not play, 1=lane N plays exclusively, 2=lane N plays and other lanes also play (fine to call with setNewValue, but returned value is read-only)
C_ALLLANESPLAY : char * : on fixed lane tracks, 0=no lanes play, 1=all lanes play, 2=some lanes play (fine to call with setNewValue 0 or 1, but returned value is read-only)
C_BEATATTACHMODE : char * : track timebase, -1=project default, 0=time, 1=beats (position, length, rate), 2=beats (position only)
F_MCP_FXSEND_SCALE : float * : scale of fx+send area in MCP (0=minimum allowed, 1=maximum allowed)
F_MCP_FXPARM_SCALE : float * : scale of fx parameter area in MCP (0=minimum allowed, 1=maximum allowed)
F_MCP_SENDRGN_SCALE : float * : scale of send area as proportion of the fx+send total area (0=minimum allowed, 1=maximum allowed)
F_TCP_FXPARM_SCALE : float * : scale of TCP parameter area when TCP FX are embedded (0=min allowed, default, 1=max allowed)
I_PLAY_OFFSET_FLAG : int * : track media playback offset state, &1=bypassed, &2=offset value is measured in samples (otherwise measured in seconds)
D_PLAY_OFFSET : double * : track media playback offset, units depend on I_PLAY_OFFSET_FLAG
P_PARTRACK : MediaTrack * : parent track (read-only)
P_PROJECT : ReaProject * : parent project (read-only)

bool GetMIDIInputName(int dev, char* nameout, int nameout_sz)
bool GetMIDIInputName(int dev, #nameout)
boolean retval, string nameout = reaper.GetMIDIInputName(integer dev, string nameout)
(Boolean retval, Int dev, String nameout, Int nameout_sz) = RPR_GetMIDIInputName(dev, nameout, nameout_sz)

returns true if device present

bool GetMIDIOutputName(int dev, char* nameout, int nameout_sz)
bool GetMIDIOutputName(int dev, #nameout)
boolean retval, string nameout = reaper.GetMIDIOutputName(integer dev, string nameout)
(Boolean retval, Int dev, String nameout, Int nameout_sz) = RPR_GetMIDIOutputName(dev, nameout, nameout_sz)

returns true if device present

MediaTrack* GetMixerScroll()
MediaTrack GetMixerScroll()
MediaTrack reaper.GetMixerScroll()
MediaTrack RPR_GetMixerScroll()

Get the leftmost track visible in the mixer

void GetMouseModifier(const char* context, int modifier_flag, char* actionOut, int actionOut_sz)
GetMouseModifier("context", int modifier_flag, #action)
string action = reaper.GetMouseModifier(string context, integer modifier_flag)
(String context, Int modifier_flag, String actionOut, Int actionOut_sz) = RPR_GetMouseModifier(context, modifier_flag, actionOut, actionOut_sz)

Get the current mouse modifier assignment for a specific modifier key assignment, in a specific context.
action will be filled in with the command ID number for a built-in mouse modifier
or built-in REAPER command ID, or the custom action ID string.
Note: the action string may have a space and 'c' or 'm' appended to it to specify command ID vs mouse modifier ID.
See SetMouseModifier for more information.

void GetMousePosition(int* xOut, int* yOut)
GetMousePosition(int &x, int &y)
integer x, integer y = reaper.GetMousePosition()
(Int xOut, Int yOut) = RPR_GetMousePosition(xOut, yOut)

get mouse position in screen coordinates

int GetNumAudioInputs()
int GetNumAudioInputs()
integer reaper.GetNumAudioInputs()
Int RPR_GetNumAudioInputs()

Return number of normal audio hardware inputs available

int GetNumAudioOutputs()
int GetNumAudioOutputs()
integer reaper.GetNumAudioOutputs()
Int RPR_GetNumAudioOutputs()

Return number of normal audio hardware outputs available

int GetNumMIDIInputs()
int GetNumMIDIInputs()
integer reaper.GetNumMIDIInputs()
Int RPR_GetNumMIDIInputs()

returns max number of real midi hardware inputs

int GetNumMIDIOutputs()
int GetNumMIDIOutputs()
integer reaper.GetNumMIDIOutputs()
Int RPR_GetNumMIDIOutputs()

returns max number of real midi hardware outputs

int GetNumTakeMarkers(MediaItem_Take* take)
int GetNumTakeMarkers(MediaItem_Take take)
integer reaper.GetNumTakeMarkers(MediaItem_Take take)
Int RPR_GetNumTakeMarkers(MediaItem_Take take)

Returns number of take markers. See GetTakeMarker, SetTakeMarker, DeleteTakeMarker

int GetNumTracks()
int GetNumTracks()
integer reaper.GetNumTracks()
Int RPR_GetNumTracks()
const char* GetOS()
bool GetOS(#retval)
string reaper.GetOS()
String RPR_GetOS()

Returns "Win32", "Win64", "OSX32", "OSX64", "macOS-arm64", or "Other".

const char* GetOutputChannelName(int channelIndex)
bool GetOutputChannelName(#retval, int channelIndex)
string reaper.GetOutputChannelName(integer channelIndex)
String RPR_GetOutputChannelName(Int channelIndex)
double GetOutputLatency()
double GetOutputLatency()
number reaper.GetOutputLatency()
Float RPR_GetOutputLatency()

returns output latency in seconds

MediaTrack* GetParentTrack(MediaTrack* track)
MediaTrack GetParentTrack(MediaTrack track)
MediaTrack reaper.GetParentTrack(MediaTrack track)
MediaTrack RPR_GetParentTrack(MediaTrack track)
void GetPeakFileName(const char* fn, char* bufOut, int bufOut_sz)
GetPeakFileName("fn", #buf)
string buf = reaper.GetPeakFileName(string fn)
(String fn, String bufOut, Int bufOut_sz) = RPR_GetPeakFileName(fn, bufOut, bufOut_sz)

get the peak file name for a given file (can be either filename.reapeaks,or a hashed filename in another path)

void GetPeakFileNameEx(const char* fn, char* buf, int buf_sz, bool forWrite)
GetPeakFileNameEx("fn", #buf, bool forWrite)
string buf = reaper.GetPeakFileNameEx(string fn, string buf, boolean forWrite)
(String fn, String buf, Int buf_sz, Boolean forWrite) = RPR_GetPeakFileNameEx(fn, buf, buf_sz, forWrite)

get the peak file name for a given file (can be either filename.reapeaks,or a hashed filename in another path)

void GetPeakFileNameEx2(const char* fn, char* buf, int buf_sz, bool forWrite, const char* peaksfileextension)
GetPeakFileNameEx2("fn", #buf, bool forWrite, "peaksfileextension")
string buf = reaper.GetPeakFileNameEx2(string fn, string buf, boolean forWrite, string peaksfileextension)
(String fn, String buf, Int buf_sz, Boolean forWrite, String peaksfileextension) = RPR_GetPeakFileNameEx2(fn, buf, buf_sz, forWrite, peaksfileextension)

Like GetPeakFileNameEx, but you can specify peaksfileextension such as ".reapeaks"

double GetPlayPosition()
double GetPlayPosition()
number reaper.GetPlayPosition()
Float RPR_GetPlayPosition()

returns latency-compensated actual-what-you-hear position

double GetPlayPosition2()
double GetPlayPosition2()
number reaper.GetPlayPosition2()
Float RPR_GetPlayPosition2()

returns position of next audio block being processed

double GetPlayPosition2Ex(ReaProject* proj)
double GetPlayPosition2Ex(ReaProject proj)
number reaper.GetPlayPosition2Ex(ReaProject proj)
Float RPR_GetPlayPosition2Ex(ReaProject proj)

returns position of next audio block being processed

double GetPlayPositionEx(ReaProject* proj)
double GetPlayPositionEx(ReaProject proj)
number reaper.GetPlayPositionEx(ReaProject proj)
Float RPR_GetPlayPositionEx(ReaProject proj)

returns latency-compensated actual-what-you-hear position

int GetPlayState()
int GetPlayState()
integer reaper.GetPlayState()
Int RPR_GetPlayState()

&1=playing, &2=paused, &4=is recording

int GetPlayStateEx(ReaProject* proj)
int GetPlayStateEx(ReaProject proj)
integer reaper.GetPlayStateEx(ReaProject proj)
Int RPR_GetPlayStateEx(ReaProject proj)

&1=playing, &2=paused, &4=is recording

double GetProjectLength(ReaProject* proj)
double GetProjectLength(ReaProject proj)
number reaper.GetProjectLength(ReaProject proj)
Float RPR_GetProjectLength(ReaProject proj)

returns length of project (maximum of end of media item, markers, end of regions, tempo map

void GetProjectName(ReaProject* proj, char* bufOut, int bufOut_sz)
GetProjectName(ReaProject proj, #buf)
string buf = reaper.GetProjectName(ReaProject proj)
(ReaProject proj, String bufOut, Int bufOut_sz) = RPR_GetProjectName(proj, bufOut, bufOut_sz)
void GetProjectPath(char* bufOut, int bufOut_sz)
GetProjectPath(#buf)
string buf = reaper.GetProjectPath()
(String bufOut, Int bufOut_sz) = RPR_GetProjectPath(bufOut, bufOut_sz)

Get the project recording path.

void GetProjectPathEx(ReaProject* proj, char* bufOut, int bufOut_sz)
GetProjectPathEx(ReaProject proj, #buf)
string buf = reaper.GetProjectPathEx(ReaProject proj)
(ReaProject proj, String bufOut, Int bufOut_sz) = RPR_GetProjectPathEx(proj, bufOut, bufOut_sz)

Get the project recording path.

int GetProjectStateChangeCount(ReaProject* proj)
int GetProjectStateChangeCount(ReaProject proj)
integer reaper.GetProjectStateChangeCount(ReaProject proj)
Int RPR_GetProjectStateChangeCount(ReaProject proj)

returns an integer that changes when the project state changes

double GetProjectTimeOffset(ReaProject* proj, bool rndframe)
double GetProjectTimeOffset(ReaProject proj, bool rndframe)
number reaper.GetProjectTimeOffset(ReaProject proj, boolean rndframe)
Float RPR_GetProjectTimeOffset(ReaProject proj, Boolean rndframe)

Gets project time offset in seconds (project settings - project start time). If rndframe is true, the offset is rounded to a multiple of the project frame size.

void GetProjectTimeSignature(double* bpmOut, double* bpiOut)
GetProjectTimeSignature(&bpm, &bpi)
number bpm, number bpi = reaper.GetProjectTimeSignature()
(Float bpmOut, Float bpiOut) = RPR_GetProjectTimeSignature(bpmOut, bpiOut)

deprecated

void GetProjectTimeSignature2(ReaProject* proj, double* bpmOut, double* bpiOut)
GetProjectTimeSignature2(ReaProject proj, &bpm, &bpi)
number bpm, number bpi = reaper.GetProjectTimeSignature2(ReaProject proj)
(ReaProject proj, Float bpmOut, Float bpiOut) = RPR_GetProjectTimeSignature2(proj, bpmOut, bpiOut)

Gets basic time signature (beats per minute, numerator of time signature in bpi)
this does not reflect tempo envelopes but is purely what is set in the project settings.

int GetProjExtState(ReaProject* proj, const char* extname, const char* key, char* valOutNeedBig, int valOutNeedBig_sz)
int GetProjExtState(ReaProject proj, "extname", "key", #val)
integer retval, string val = reaper.GetProjExtState(ReaProject proj, string extname, string key)
(Int retval, ReaProject proj, String extname, String key, String valOutNeedBig, Int valOutNeedBig_sz) = RPR_GetProjExtState(proj, extname, key, valOutNeedBig, valOutNeedBig_sz)

Get the value previously associated with this extname and key, the last time the project was saved. See SetProjExtState, EnumProjExtState.

const char* GetResourcePath()
bool GetResourcePath(#retval)
string reaper.GetResourcePath()
String RPR_GetResourcePath()

returns path where ini files are stored, other things are in subdirectories.

TrackEnvelope* GetSelectedEnvelope(ReaProject* proj)
TrackEnvelope GetSelectedEnvelope(ReaProject proj)
TrackEnvelope reaper.GetSelectedEnvelope(ReaProject proj)
TrackEnvelope RPR_GetSelectedEnvelope(ReaProject proj)

get the currently selected envelope, returns NULL/nil if no envelope is selected

MediaItem* GetSelectedMediaItem(ReaProject* proj, int selitem)
MediaItem GetSelectedMediaItem(ReaProject proj, int selitem)
MediaItem reaper.GetSelectedMediaItem(ReaProject proj, integer selitem)
MediaItem RPR_GetSelectedMediaItem(ReaProject proj, Int selitem)

get a selected item by selected item count (zero-based) (proj=0 for active project)

MediaTrack* GetSelectedTrack(ReaProject* proj, int seltrackidx)
MediaTrack GetSelectedTrack(ReaProject proj, int seltrackidx)
MediaTrack reaper.GetSelectedTrack(ReaProject proj, integer seltrackidx)
MediaTrack RPR_GetSelectedTrack(ReaProject proj, Int seltrackidx)

Get a selected track from a project (proj=0 for active project) by selected track count (zero-based). This function ignores the master track, see GetSelectedTrack2.

MediaTrack* GetSelectedTrack2(ReaProject* proj, int seltrackidx, bool wantmaster)
MediaTrack GetSelectedTrack2(ReaProject proj, int seltrackidx, bool wantmaster)
MediaTrack reaper.GetSelectedTrack2(ReaProject proj, integer seltrackidx, boolean wantmaster)
MediaTrack RPR_GetSelectedTrack2(ReaProject proj, Int seltrackidx, Boolean wantmaster)

Get a selected track from a project (proj=0 for active project) by selected track count (zero-based).

TrackEnvelope* GetSelectedTrackEnvelope(ReaProject* proj)
TrackEnvelope GetSelectedTrackEnvelope(ReaProject proj)
TrackEnvelope reaper.GetSelectedTrackEnvelope(ReaProject proj)
TrackEnvelope RPR_GetSelectedTrackEnvelope(ReaProject proj)

get the currently selected track envelope, returns NULL/nil if no envelope is selected

void GetSet_ArrangeView2(ReaProject* proj, bool isSet, int screen_x_start, int screen_x_end, double* start_timeInOut, double* end_timeInOut)
GetSet_ArrangeView2(ReaProject proj, bool isSet, int screen_x_start, int screen_x_end, &start_time, &end_time)
number start_time, number end_time = reaper.GetSet_ArrangeView2(ReaProject proj, boolean isSet, integer screen_x_start, integer screen_x_end, number start_time, number end_time)
(ReaProject proj, Boolean isSet, Int screen_x_start, Int screen_x_end, Float start_timeInOut, Float end_timeInOut) = RPR_GetSet_ArrangeView2(proj, isSet, screen_x_start, screen_x_end, start_timeInOut, end_timeInOut)

Gets or sets the arrange view start/end time for screen coordinates. use screen_x_start=screen_x_end=0 to use the full arrange view's start/end time

void GetSet_LoopTimeRange(bool isSet, bool isLoop, double* startOut, double* endOut, bool allowautoseek)
GetSet_LoopTimeRange(bool isSet, bool isLoop, &start, &end, bool allowautoseek)
number start, number end = reaper.GetSet_LoopTimeRange(boolean isSet, boolean isLoop, number start, number end, boolean allowautoseek)
(Boolean isSet, Boolean isLoop, Float startOut, Float endOut, Boolean allowautoseek) = RPR_GetSet_LoopTimeRange(isSet, isLoop, startOut, endOut, allowautoseek)
void GetSet_LoopTimeRange2(ReaProject* proj, bool isSet, bool isLoop, double* startOut, double* endOut, bool allowautoseek)
GetSet_LoopTimeRange2(ReaProject proj, bool isSet, bool isLoop, &start, &end, bool allowautoseek)
number start, number end = reaper.GetSet_LoopTimeRange2(ReaProject proj, boolean isSet, boolean isLoop, number start, number end, boolean allowautoseek)
(ReaProject proj, Boolean isSet, Boolean isLoop, Float startOut, Float endOut, Boolean allowautoseek) = RPR_GetSet_LoopTimeRange2(proj, isSet, isLoop, startOut, endOut, allowautoseek)
double GetSetAutomationItemInfo(TrackEnvelope* env, int autoitem_idx, const char* desc, double value, bool is_set)
double GetSetAutomationItemInfo(TrackEnvelope env, int autoitem_idx, "desc", value, bool is_set)
number reaper.GetSetAutomationItemInfo(TrackEnvelope env, integer autoitem_idx, string desc, number value, boolean is_set)
Float RPR_GetSetAutomationItemInfo(TrackEnvelope env, Int autoitem_idx, String desc, Float value, Boolean is_set)

Get or set automation item information. autoitem_idx=0 for the first automation item on an envelope, 1 for the second item, etc. desc can be any of the following:
D_POOL_ID : double * : automation item pool ID (as an integer); edits are propagated to all other automation items that share a pool ID
D_POSITION : double * : automation item timeline position in seconds
D_LENGTH : double * : automation item length in seconds
D_STARTOFFS : double * : automation item start offset in seconds
D_PLAYRATE : double * : automation item playback rate
D_BASELINE : double * : automation item baseline value in the range [0,1]
D_AMPLITUDE : double * : automation item amplitude in the range [-1,1]
D_LOOPSRC : double * : nonzero if the automation item contents are looped
D_UISEL : double * : nonzero if the automation item is selected in the arrange view
D_POOL_QNLEN : double * : automation item pooled source length in quarter notes (setting will affect all pooled instances)

bool GetSetAutomationItemInfo_String(TrackEnvelope* env, int autoitem_idx, const char* desc, char* valuestrNeedBig, bool is_set)
bool GetSetAutomationItemInfo_String(TrackEnvelope env, int autoitem_idx, "desc", #valuestrNeedBig, bool is_set)
boolean retval, string valuestrNeedBig = reaper.GetSetAutomationItemInfo_String(TrackEnvelope env, integer autoitem_idx, string desc, string valuestrNeedBig, boolean is_set)
(Boolean retval, TrackEnvelope env, Int autoitem_idx, String desc, String valuestrNeedBig, Boolean is_set) = RPR_GetSetAutomationItemInfo_String(env, autoitem_idx, desc, valuestrNeedBig, is_set)

Get or set automation item information. autoitem_idx=0 for the first automation item on an envelope, 1 for the second item, etc. returns true on success. desc can be any of the following:
P_POOL_NAME : char * : name of the underlying automation item pool
P_POOL_EXT:xyz : char * : extension-specific persistent data

bool GetSetEnvelopeInfo_String(TrackEnvelope* env, const char* parmname, char* stringNeedBig, bool setNewValue)
bool GetSetEnvelopeInfo_String(TrackEnvelope env, "parmname", #stringNeedBig, bool setNewValue)
boolean retval, string stringNeedBig = reaper.GetSetEnvelopeInfo_String(TrackEnvelope env, string parmname, string stringNeedBig, boolean setNewValue)
(Boolean retval, TrackEnvelope env, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetEnvelopeInfo_String(env, parmname, stringNeedBig, setNewValue)

Gets/sets an attribute string:
P_EXT:xyz : char * : extension-specific persistent data
GUID : GUID * : 16-byte GUID, can query only, not set. If using a _String() function, GUID is a string {xyz-...}.

bool GetSetEnvelopeState(TrackEnvelope* env, char* str, int str_sz)
bool GetSetEnvelopeState(TrackEnvelope env, #str)
boolean retval, string str = reaper.GetSetEnvelopeState(TrackEnvelope env, string str)
(Boolean retval, TrackEnvelope env, String str, Int str_sz) = RPR_GetSetEnvelopeState(env, str, str_sz)

deprecated -- see SetEnvelopeStateChunk, GetEnvelopeStateChunk

bool GetSetEnvelopeState2(TrackEnvelope* env, char* str, int str_sz, bool isundo)
bool GetSetEnvelopeState2(TrackEnvelope env, #str, bool isundo)
boolean retval, string str = reaper.GetSetEnvelopeState2(TrackEnvelope env, string str, boolean isundo)
(Boolean retval, TrackEnvelope env, String str, Int str_sz, Boolean isundo) = RPR_GetSetEnvelopeState2(env, str, str_sz, isundo)

deprecated -- see SetEnvelopeStateChunk, GetEnvelopeStateChunk

bool GetSetItemState(MediaItem* item, char* str, int str_sz)
bool GetSetItemState(MediaItem item, #str)
boolean retval, string str = reaper.GetSetItemState(MediaItem item, string str)
(Boolean retval, MediaItem item, String str, Int str_sz) = RPR_GetSetItemState(item, str, str_sz)

deprecated -- see SetItemStateChunk, GetItemStateChunk

bool GetSetItemState2(MediaItem* item, char* str, int str_sz, bool isundo)
bool GetSetItemState2(MediaItem item, #str, bool isundo)
boolean retval, string str = reaper.GetSetItemState2(MediaItem item, string str, boolean isundo)
(Boolean retval, MediaItem item, String str, Int str_sz, Boolean isundo) = RPR_GetSetItemState2(item, str, str_sz, isundo)

deprecated -- see SetItemStateChunk, GetItemStateChunk

bool GetSetMediaItemInfo_String(MediaItem* item, const char* parmname, char* stringNeedBig, bool setNewValue)
bool GetSetMediaItemInfo_String(MediaItem item, "parmname", #stringNeedBig, bool setNewValue)
boolean retval, string stringNeedBig = reaper.GetSetMediaItemInfo_String(MediaItem item, string parmname, string stringNeedBig, boolean setNewValue)
(Boolean retval, MediaItem item, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetMediaItemInfo_String(item, parmname, stringNeedBig, setNewValue)

Gets/sets an item attribute string:
P_NOTES : char * : item note text (do not write to returned pointer, use setNewValue to update)
P_EXT:xyz : char * : extension-specific persistent data
GUID : GUID * : 16-byte GUID, can query or update. If using a _String() function, GUID is a string {xyz-...}.

bool GetSetMediaItemTakeInfo_String(MediaItem_Take* tk, const char* parmname, char* stringNeedBig, bool setNewValue)
bool GetSetMediaItemTakeInfo_String(MediaItem_Take tk, "parmname", #stringNeedBig, bool setNewValue)
boolean retval, string stringNeedBig = reaper.GetSetMediaItemTakeInfo_String(MediaItem_Take tk, string parmname, string stringNeedBig, boolean setNewValue)
(Boolean retval, MediaItem_Take tk, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetMediaItemTakeInfo_String(tk, parmname, stringNeedBig, setNewValue)

Gets/sets a take attribute string:
P_NAME : char * : take name
P_EXT:xyz : char * : extension-specific persistent data
GUID : GUID * : 16-byte GUID, can query or update. If using a _String() function, GUID is a string {xyz-...}.

bool GetSetMediaTrackInfo_String(MediaTrack* tr, const char* parmname, char* stringNeedBig, bool setNewValue)
bool GetSetMediaTrackInfo_String(MediaTrack tr, "parmname", #stringNeedBig, bool setNewValue)
boolean retval, string stringNeedBig = reaper.GetSetMediaTrackInfo_String(MediaTrack tr, string parmname, string stringNeedBig, boolean setNewValue)
(Boolean retval, MediaTrack tr, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetMediaTrackInfo_String(tr, parmname, stringNeedBig, setNewValue)

Get or set track string attributes.
P_NAME : char * : track name (on master returns NULL)
P_ICON : const char * : track icon (full filename, or relative to resource_path/data/track_icons)
P_LANENAME:n : char * : lane name (returns NULL for non-fixed-lane-tracks)
P_MCP_LAYOUT : const char * : layout name
P_RAZOREDITS : const char * : list of razor edit areas, as space-separated triples of start time, end time, and envelope GUID string.
Example: "0.0 1.0 \"\" 0.0 1.0 "{xyz-...}"
P_RAZOREDITS_EXT : const char * : list of razor edit areas, as comma-separated sets of space-separated tuples of start time, end time, optional: envelope GUID string, fixed/fipm top y-position, fixed/fipm bottom y-position.
Example: "0.0 1.0,0.0 1.0 "{xyz-...}",1.0 2.0 "" 0.25 0.75"
P_TCP_LAYOUT : const char * : layout name
P_EXT:xyz : char * : extension-specific persistent data
P_UI_RECT:tcp.mute : char * : read-only, allows querying screen position + size of track WALTER elements (tcp.size queries screen position and size of entire TCP, etc).
GUID : GUID * : 16-byte GUID, can query or update. If using a _String() function, GUID is a string {xyz-...}.

void GetSetProjectAuthor(ReaProject* proj, bool set, char* author, int author_sz)
GetSetProjectAuthor(ReaProject proj, bool set, #author)
string author = reaper.GetSetProjectAuthor(ReaProject proj, boolean set, string author)
(ReaProject proj, Boolean set, String author, Int author_sz) = RPR_GetSetProjectAuthor(proj, set, author, author_sz)

deprecated, see GetSetProjectInfo_String with desc="PROJECT_AUTHOR"

int GetSetProjectGrid(ReaProject* project, bool set, double* divisionInOutOptional, int* swingmodeInOutOptional, double* swingamtInOutOptional)
int GetSetProjectGrid(ReaProject project, bool set, optional &division, optional int &swingmode, optional &swingamt)
integer retval, optional number division, optional integer swingmode, optional number swingamt = reaper.GetSetProjectGrid(ReaProject project, boolean set, optional number division, optional integer swingmode, optional number swingamt)
(Int retval, ReaProject project, Boolean set, Float divisionInOutOptional, Int swingmodeInOutOptional, Float swingamtInOutOptional) = RPR_GetSetProjectGrid(project, set, divisionInOutOptional, swingmodeInOutOptional, swingamtInOutOptional)

Get or set the arrange view grid division. 0.25=quarter note, 1.0/3.0=half note triplet, etc. swingmode can be 1 for swing enabled, swingamt is -1..1. swingmode can be 3 for measure-grid. Returns grid configuration flags

double GetSetProjectInfo(ReaProject* project, const char* desc, double value, bool is_set)
double GetSetProjectInfo(ReaProject project, "desc", value, bool is_set)
number reaper.GetSetProjectInfo(ReaProject project, string desc, number value, boolean is_set)
Float RPR_GetSetProjectInfo(ReaProject project, String desc, Float value, Boolean is_set)

Get or set project information.
RENDER_SETTINGS : &(1|2)=0:master mix, &1=stems+master mix, &2=stems only, &4=multichannel tracks to multichannel files, &8=use render matrix, &16=tracks with only mono media to mono files, &32=selected media items, &64=selected media items via master, &128=selected tracks via master, &256=embed transients if format supports, &512=embed metadata if format supports, &1024=embed take markers if format supports, &2048=2nd pass render
RENDER_BOUNDSFLAG : 0=custom time bounds, 1=entire project, 2=time selection, 3=all project regions, 4=selected media items, 5=selected project regions, 6=all project markers, 7=selected project markers
RENDER_CHANNELS : number of channels in rendered file
RENDER_SRATE : sample rate of rendered file (or 0 for project sample rate)
RENDER_STARTPOS : render start time when RENDER_BOUNDSFLAG=0
RENDER_ENDPOS : render end time when RENDER_BOUNDSFLAG=0
RENDER_TAILFLAG : apply render tail setting when rendering: &1=custom time bounds, &2=entire project, &4=time selection, &8=all project markers/regions, &16=selected media items, &32=selected project markers/regions
RENDER_TAILMS : tail length in ms to render (only used if RENDER_BOUNDSFLAG and RENDER_TAILFLAG are set)
RENDER_ADDTOPROJ : &1=add rendered files to project, &2=do not render files that are likely silent
RENDER_DITHER : &1=dither, &2=noise shaping, &4=dither stems, &8=noise shaping on stems
RENDER_NORMALIZE: &1=enable, (&14==0)=LUFS-I, (&14==2)=RMS, (&14==4)=peak, (&14==6)=true peak, (&14==8)=LUFS-M max, (&14==10)=LUFS-S max, &32=normalize stems to common gain based on master, &64=enable brickwall limit, &128=brickwall limit true peak, (&2304==256)=only normalize files that are too loud, (&2304==2048)=only normalize files that are too quiet, &512=apply fade-in, &1024=apply fade-out
RENDER_NORMALIZE_TARGET: render normalization target as amplitude, so 0.5 means -6.02dB, 0.25 means -12.04dB, etc
RENDER_BRICKWALL: render brickwall limit as amplitude, so 0.5 means -6.02dB, 0.25 means -12.04dB, etc
RENDER_FADEIN: render fade-in (0.001 means 1 ms, requires RENDER_NORMALIZE&512)
RENDER_FADEOUT: render fade-out (0.001 means 1 ms, requires RENDER_NORMALIZE&1024)
RENDER_FADEINSHAPE: render fade-in shape
RENDER_FADEOUTSHAPE: render fade-out shape
PROJECT_SRATE : samplerate (ignored unless PROJECT_SRATE_USE set)
PROJECT_SRATE_USE : set to 1 if project samplerate is used

bool GetSetProjectInfo_String(ReaProject* project, const char* desc, char* valuestrNeedBig, bool is_set)
bool GetSetProjectInfo_String(ReaProject project, "desc", #valuestrNeedBig, bool is_set)
boolean retval, string valuestrNeedBig = reaper.GetSetProjectInfo_String(ReaProject project, string desc, string valuestrNeedBig, boolean is_set)
(Boolean retval, ReaProject project, String desc, String valuestrNeedBig, Boolean is_set) = RPR_GetSetProjectInfo_String(project, desc, valuestrNeedBig, is_set)

Get or set project information.
PROJECT_NAME : project file name (read-only, is_set will be ignored)
PROJECT_TITLE : title field from Project Settings/Notes dialog
PROJECT_AUTHOR : author field from Project Settings/Notes dialog
TRACK_GROUP_NAME:X : track group name, X should be 1..64
MARKER_GUID:X : get the GUID (unique ID) of the marker or region with index X, where X is the index passed to EnumProjectMarkers, not necessarily the displayed number (read-only)
MARKER_INDEX_FROM_GUID:{GUID} : get the GUID index of the marker or region with GUID {GUID} (read-only)
OPENCOPY_CFGIDX : integer for the configuration of format to use when creating copies/applying FX. 0=wave (auto-depth), 1=APPLYFX_FORMAT, 2=RECORD_FORMAT
RECORD_PATH : recording directory -- may be blank or a relative path, to get the effective path see GetProjectPathEx()
RECORD_PATH_SECONDARY : secondary recording directory
RECORD_FORMAT : base64-encoded sink configuration (see project files, etc). Callers can also pass a simple 4-byte string (non-base64-encoded), e.g. "evaw" or "l3pm", to use default settings for that sink type.
APPLYFX_FORMAT : base64-encoded sink configuration (see project files, etc). Used only if RECFMT_OPENCOPY is set to 1. Callers can also pass a simple 4-byte string (non-base64-encoded), e.g. "evaw" or "l3pm", to use default settings for that sink type.
RENDER_FILE : render directory
RENDER_PATTERN : render file name (may contain wildcards)
RENDER_METADATA : get or set the metadata saved with the project (not metadata embedded in project media). Example, ID3 album name metadata: valuestr="ID3:TALB" to get, valuestr="ID3:TALB|my album name" to set. Call with valuestr="" and is_set=false to get a semicolon-separated list of defined project metadata identifiers.
RENDER_TARGETS : semicolon separated list of files that would be written if the project is rendered using the most recent render settings
RENDER_STATS : (read-only) semicolon separated list of statistics for the most recently rendered files. call with valuestr="XXX" to run an action (for example, "42437"=dry run render selected items) before returning statistics.
RENDER_FORMAT : base64-encoded sink configuration (see project files, etc). Callers can also pass a simple 4-byte string (non-base64-encoded), e.g. "evaw" or "l3pm", to use default settings for that sink type.
RENDER_FORMAT2 : base64-encoded secondary sink configuration. Callers can also pass a simple 4-byte string (non-base64-encoded), e.g. "evaw" or "l3pm", to use default settings for that sink type, or "" to disable secondary render.
    Formats available on this machine:
    "wave" "aiff" "caff" "raw " "iso " "ddp " "flac" "mp3l" "oggv" "OggS" "FFMP" "WMF " "GIF " "LCF " "wvpk"

void GetSetProjectNotes(ReaProject* proj, bool set, char* notesNeedBig, int notesNeedBig_sz)
GetSetProjectNotes(ReaProject proj, bool set, #notes)
string notes = reaper.GetSetProjectNotes(ReaProject proj, boolean set, string notes)
(ReaProject proj, Boolean set, String notesNeedBig, Int notesNeedBig_sz) = RPR_GetSetProjectNotes(proj, set, notesNeedBig, notesNeedBig_sz)

gets or sets project notes, notesNeedBig_sz is ignored when setting

int GetSetRepeat(int val)
int GetSetRepeat(int val)
integer reaper.GetSetRepeat(integer val)
Int RPR_GetSetRepeat(Int val)

-1 == query,0=clear,1=set,>1=toggle . returns new value

int GetSetRepeatEx(ReaProject* proj, int val)
int GetSetRepeatEx(ReaProject proj, int val)
integer reaper.GetSetRepeatEx(ReaProject proj, integer val)
Int RPR_GetSetRepeatEx(ReaProject proj, Int val)

-1 == query,0=clear,1=set,>1=toggle . returns new value

unsigned int GetSetTrackGroupMembership(MediaTrack* tr, const char* groupname, unsigned int setmask, unsigned int setvalue)
uint GetSetTrackGroupMembership(MediaTrack tr, "groupname", uint setmask, uint setvalue)
integer reaper.GetSetTrackGroupMembership(MediaTrack tr, string groupname, integer setmask, integer setvalue)
Unknown RPR_GetSetTrackGroupMembership(MediaTrack tr, String groupname, Unknown setmask, Unknown setvalue)

Gets or modifies the group membership for a track. Returns group state prior to call (each bit represents one of the 32 group numbers). if setmask has bits set, those bits in setvalue will be applied to group. Group can be one of:
MEDIA_EDIT_LEAD
MEDIA_EDIT_FOLLOW
VOLUME_LEAD
VOLUME_FOLLOW
VOLUME_VCA_LEAD
VOLUME_VCA_FOLLOW
PAN_LEAD
PAN_FOLLOW
WIDTH_LEAD
WIDTH_FOLLOW
MUTE_LEAD
MUTE_FOLLOW
SOLO_LEAD
SOLO_FOLLOW
RECARM_LEAD
RECARM_FOLLOW
POLARITY_LEAD
POLARITY_FOLLOW
AUTOMODE_LEAD
AUTOMODE_FOLLOW
VOLUME_REVERSE
PAN_REVERSE
WIDTH_REVERSE
NO_LEAD_WHEN_FOLLOW
VOLUME_VCA_FOLLOW_ISPREFX

Note: REAPER v6.11 and earlier used _MASTER and _SLAVE rather than _LEAD and _FOLLOW, which is deprecated but still supported (scripts that must support v6.11 and earlier can use the deprecated strings).

unsigned int GetSetTrackGroupMembershipHigh(MediaTrack* tr, const char* groupname, unsigned int setmask, unsigned int setvalue)
uint GetSetTrackGroupMembershipHigh(MediaTrack tr, "groupname", uint setmask, uint setvalue)
integer reaper.GetSetTrackGroupMembershipHigh(MediaTrack tr, string groupname, integer setmask, integer setvalue)
Unknown RPR_GetSetTrackGroupMembershipHigh(MediaTrack tr, String groupname, Unknown setmask, Unknown setvalue)

Gets or modifies the group membership for a track. Returns group state prior to call (each bit represents one of the high 32 group numbers). if setmask has bits set, those bits in setvalue will be applied to group. Group can be one of:
MEDIA_EDIT_LEAD
MEDIA_EDIT_FOLLOW
VOLUME_LEAD
VOLUME_FOLLOW
VOLUME_VCA_LEAD
VOLUME_VCA_FOLLOW
PAN_LEAD
PAN_FOLLOW
WIDTH_LEAD
WIDTH_FOLLOW
MUTE_LEAD
MUTE_FOLLOW
SOLO_LEAD
SOLO_FOLLOW
RECARM_LEAD
RECARM_FOLLOW
POLARITY_LEAD
POLARITY_FOLLOW
AUTOMODE_LEAD
AUTOMODE_FOLLOW
VOLUME_REVERSE
PAN_REVERSE
WIDTH_REVERSE
NO_LEAD_WHEN_FOLLOW
VOLUME_VCA_FOLLOW_ISPREFX

Note: REAPER v6.11 and earlier used _MASTER and _SLAVE rather than _LEAD and _FOLLOW, which is deprecated but still supported (scripts that must support v6.11 and earlier can use the deprecated strings).

bool GetSetTrackSendInfo_String(MediaTrack* tr, int category, int sendidx, const char* parmname, char* stringNeedBig, bool setNewValue)
bool GetSetTrackSendInfo_String(MediaTrack tr, int category, int sendidx, "parmname", #stringNeedBig, bool setNewValue)
boolean retval, string stringNeedBig = reaper.GetSetTrackSendInfo_String(MediaTrack tr, integer category, integer sendidx, string parmname, string stringNeedBig, boolean setNewValue)
(Boolean retval, MediaTrack tr, Int category, Int sendidx, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetTrackSendInfo_String(tr, category, sendidx, parmname, stringNeedBig, setNewValue)

Gets/sets a send attribute string:
P_EXT:xyz : char * : extension-specific persistent data

bool GetSetTrackState(MediaTrack* track, char* str, int str_sz)
bool GetSetTrackState(MediaTrack track, #str)
boolean retval, string str = reaper.GetSetTrackState(MediaTrack track, string str)
(Boolean retval, MediaTrack track, String str, Int str_sz) = RPR_GetSetTrackState(track, str, str_sz)

deprecated -- see SetTrackStateChunk, GetTrackStateChunk

bool GetSetTrackState2(MediaTrack* track, char* str, int str_sz, bool isundo)
bool GetSetTrackState2(MediaTrack track, #str, bool isundo)
boolean retval, string str = reaper.GetSetTrackState2(MediaTrack track, string str, boolean isundo)
(Boolean retval, MediaTrack track, String str, Int str_sz, Boolean isundo) = RPR_GetSetTrackState2(track, str, str_sz, isundo)

deprecated -- see SetTrackStateChunk, GetTrackStateChunk

ReaProject* GetSubProjectFromSource(PCM_source* src)
ReaProject GetSubProjectFromSource(PCM_source src)
ReaProject reaper.GetSubProjectFromSource(PCM_source src)
ReaProject RPR_GetSubProjectFromSource(PCM_source src)
MediaItem_Take* GetTake(MediaItem* item, int takeidx)
MediaItem_Take GetTake(MediaItem item, int takeidx)
MediaItem_Take reaper.GetTake(MediaItem item, integer takeidx)
MediaItem_Take RPR_GetTake(MediaItem item, Int takeidx)

get a take from an item by take count (zero-based)

TrackEnvelope* GetTakeEnvelope(MediaItem_Take* take, int envidx)
TrackEnvelope GetTakeEnvelope(MediaItem_Take take, int envidx)
TrackEnvelope reaper.GetTakeEnvelope(MediaItem_Take take, integer envidx)
TrackEnvelope RPR_GetTakeEnvelope(MediaItem_Take take, Int envidx)
TrackEnvelope* GetTakeEnvelopeByName(MediaItem_Take* take, const char* envname)
TrackEnvelope GetTakeEnvelopeByName(MediaItem_Take take, "envname")
TrackEnvelope reaper.GetTakeEnvelopeByName(MediaItem_Take take, string envname)
TrackEnvelope RPR_GetTakeEnvelopeByName(MediaItem_Take take, String envname)
double GetTakeMarker(MediaItem_Take* take, int idx, char* nameOut, int nameOut_sz, int* colorOutOptional)
double GetTakeMarker(MediaItem_Take take, int idx, #name, optional int &color)
number retval, string name, optional integer color = reaper.GetTakeMarker(MediaItem_Take take, integer idx)
(Float retval, MediaItem_Take take, Int idx, String nameOut, Int nameOut_sz, Int colorOutOptional) = RPR_GetTakeMarker(take, idx, nameOut, nameOut_sz, colorOutOptional)

Get information about a take marker. Returns the position in media item source time, or -1 if the take marker does not exist. See GetNumTakeMarkers, SetTakeMarker, DeleteTakeMarker

const char* GetTakeName(MediaItem_Take* take)
bool GetTakeName(#retval, MediaItem_Take take)
string reaper.GetTakeName(MediaItem_Take take)
String RPR_GetTakeName(MediaItem_Take take)

returns NULL if the take is not valid

int GetTakeNumStretchMarkers(MediaItem_Take* take)
int GetTakeNumStretchMarkers(MediaItem_Take take)
integer reaper.GetTakeNumStretchMarkers(MediaItem_Take take)
Int RPR_GetTakeNumStretchMarkers(MediaItem_Take take)

Returns number of stretch markers in take

int GetTakeStretchMarker(MediaItem_Take* take, int idx, double* posOut, double* srcposOutOptional)
int GetTakeStretchMarker(MediaItem_Take take, int idx, &pos, optional &srcpos)
integer retval, number pos, optional number srcpos = reaper.GetTakeStretchMarker(MediaItem_Take take, integer idx)
(Int retval, MediaItem_Take take, Int idx, Float posOut, Float srcposOutOptional) = RPR_GetTakeStretchMarker(take, idx, posOut, srcposOutOptional)

Gets information on a stretch marker, idx is 0..n. Returns -1 if stretch marker not valid. posOut will be set to position in item, srcposOutOptional will be set to source media position. Returns index. if input index is -1, the following marker is found using position (or source position if position is -1). If position/source position are used to find marker position, their values are not updated.

double GetTakeStretchMarkerSlope(MediaItem_Take* take, int idx)
double GetTakeStretchMarkerSlope(MediaItem_Take take, int idx)
number reaper.GetTakeStretchMarkerSlope(MediaItem_Take take, integer idx)
Float RPR_GetTakeStretchMarkerSlope(MediaItem_Take take, Int idx)

See SetTakeStretchMarkerSlope

bool GetTCPFXParm(ReaProject* project, MediaTrack* track, int index, int* fxindexOut, int* parmidxOut)
bool GetTCPFXParm(ReaProject project, MediaTrack track, int index, int &fxindex, int &parmidx)
boolean retval, integer fxindex, integer parmidx = reaper.GetTCPFXParm(ReaProject project, MediaTrack track, integer index)
(Boolean retval, ReaProject project, MediaTrack track, Int index, Int fxindexOut, Int parmidxOut) = RPR_GetTCPFXParm(project, track, index, fxindexOut, parmidxOut)

Get information about a specific FX parameter knob (see CountTCPFXParms).

bool GetTempoMatchPlayRate(PCM_source* source, double srcscale, double position, double mult, double* rateOut, double* targetlenOut)
bool GetTempoMatchPlayRate(PCM_source source, srcscale, position, mult, &rate, &targetlen)
boolean retval, number rate, number targetlen = reaper.GetTempoMatchPlayRate(PCM_source source, number srcscale, number position, number mult)
(Boolean retval, PCM_source source, Float srcscale, Float position, Float mult, Float rateOut, Float targetlenOut) = RPR_GetTempoMatchPlayRate(source, srcscale, position, mult, rateOut, targetlenOut)

finds the playrate and target length to insert this item stretched to a round power-of-2 number of bars, between 1/8 and 256

bool GetTempoTimeSigMarker(ReaProject* proj, int ptidx, double* timeposOut, int* measureposOut, double* beatposOut, double* bpmOut, int* timesig_numOut, int* timesig_denomOut, bool* lineartempoOut)
bool GetTempoTimeSigMarker(ReaProject proj, int ptidx, &timepos, int &measurepos, &beatpos, &bpm, int &timesig_num, int &timesig_denom, bool &lineartempo)
boolean retval, number timepos, integer measurepos, number beatpos, number bpm, integer timesig_num, integer timesig_denom, boolean lineartempo = reaper.GetTempoTimeSigMarker(ReaProject proj, integer ptidx)
(Boolean retval, ReaProject proj, Int ptidx, Float timeposOut, Int measureposOut, Float beatposOut, Float bpmOut, Int timesig_numOut, Int timesig_denomOut, Boolean lineartempoOut) = RPR_GetTempoTimeSigMarker(proj, ptidx, timeposOut, measureposOut, beatposOut, bpmOut, timesig_numOut, timesig_denomOut, lineartempoOut)

Get information about a tempo/time signature marker. See CountTempoTimeSigMarkers, SetTempoTimeSigMarker, AddTempoTimeSigMarker.

int GetThemeColor(const char* ini_key, int flagsOptional)
int GetThemeColor("ini_key", int flags)
integer reaper.GetThemeColor(string ini_key, integer flags)
Int RPR_GetThemeColor(String ini_key, Int flagsOptional)

Returns the theme color specified, or -1 on failure. If the low bit of flags is set, the color as originally specified by the theme (before any transformations) is returned, otherwise the current (possibly transformed and modified) color is returned. See SetThemeColor for a list of valid ini_key.

MediaTrack* GetThingFromPoint(int screen_x, int screen_y, char* infoOut, int infoOut_sz)
MediaTrack GetThingFromPoint(int screen_x, int screen_y, #info)
MediaTrack retval, string info = reaper.GetThingFromPoint(integer screen_x, integer screen_y)
(MediaTrack retval, Int screen_x, Int screen_y, String infoOut, Int infoOut_sz) = RPR_GetThingFromPoint(screen_x, screen_y, infoOut, infoOut_sz)

Hit tests a point in screen coordinates. Updates infoOut with information such as "arrange", "fx_chain", "fx_0" (first FX in chain, floating), "spacer_0" (spacer before first track). If a track panel is hit, string will begin with "tcp" or "mcp" or "tcp.mute" etc (future versions may append additional information). May return NULL with valid info string to indicate non-track thing.

int GetToggleCommandState(int command_id)
int GetToggleCommandState(int command_id)
integer reaper.GetToggleCommandState(integer command_id)
Int RPR_GetToggleCommandState(Int command_id)

See GetToggleCommandStateEx.

int GetToggleCommandStateEx(int section_id, int command_id)
int GetToggleCommandStateEx(int section_id, int command_id)
integer reaper.GetToggleCommandStateEx(integer section_id, integer command_id)
Int RPR_GetToggleCommandStateEx(Int section_id, Int command_id)

For the main action context, the MIDI editor, or the media explorer, returns the toggle state of the action. 0=off, 1=on, -1=NA because the action does not have on/off states. For the MIDI editor, the action state for the most recently focused window will be returned.

HWND GetTooltipWindow()
HWND GetTooltipWindow()
HWND reaper.GetTooltipWindow()
HWND RPR_GetTooltipWindow()

gets a tooltip window,in case you want to ask it for font information. Can return NULL.

bool GetTouchedOrFocusedFX(int mode, int* trackidxOut, int* itemidxOut, int* takeidxOut, int* fxidxOut, int* parmOut)
bool GetTouchedOrFocusedFX(int mode, int &trackidx, int &itemidx, int &takeidx, int &fxidx, int &parm)
boolean retval, integer trackidx, integer itemidx, integer takeidx, integer fxidx, integer parm = reaper.GetTouchedOrFocusedFX(integer mode)
(Boolean retval, Int mode, Int trackidxOut, Int itemidxOut, Int takeidxOut, Int fxidxOut, Int parmOut) = RPR_GetTouchedOrFocusedFX(mode, trackidxOut, itemidxOut, takeidxOut, fxidxOut, parmOut)

mode can be 0 to query last touched parameter, or 1 to query currently focused FX. Returns false if failed. If successful, trackIdxOut will be track index (-1 is master track, 0 is first track). itemidxOut will be 0-based item index if an item, or -1 if not an item. takeidxOut will be 0-based take index. fxidxOut will be FX index, potentially with 0x2000000 set to signify container-addressing, or with 0x1000000 set to signify record-input FX. parmOut will be set to the parameter index if querying last-touched. parmOut will have 1 set if querying focused state and FX is no longer focused but still open.

MediaTrack* GetTrack(ReaProject* proj, int trackidx)
MediaTrack GetTrack(ReaProject proj, int trackidx)
MediaTrack reaper.GetTrack(ReaProject proj, integer trackidx)
MediaTrack RPR_GetTrack(ReaProject proj, Int trackidx)

get a track from a project by track count (zero-based) (proj=0 for active project)

int GetTrackAutomationMode(MediaTrack* tr)
int GetTrackAutomationMode(MediaTrack tr)
integer reaper.GetTrackAutomationMode(MediaTrack tr)
Int RPR_GetTrackAutomationMode(MediaTrack tr)

return the track mode, regardless of global override

int GetTrackColor(MediaTrack* track)
int GetTrackColor(MediaTrack track)
integer reaper.GetTrackColor(MediaTrack track)
Int RPR_GetTrackColor(MediaTrack track)

Returns the track custom color as OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). Black is returned as 0x1000000, no color setting is returned as 0.

int GetTrackDepth(MediaTrack* track)
int GetTrackDepth(MediaTrack track)
integer reaper.GetTrackDepth(MediaTrack track)
Int RPR_GetTrackDepth(MediaTrack track)
TrackEnvelope* GetTrackEnvelope(MediaTrack* track, int envidx)
TrackEnvelope GetTrackEnvelope(MediaTrack track, int envidx)
TrackEnvelope reaper.GetTrackEnvelope(MediaTrack track, integer envidx)
TrackEnvelope RPR_GetTrackEnvelope(MediaTrack track, Int envidx)
TrackEnvelope* GetTrackEnvelopeByChunkName(MediaTrack* tr, const char* cfgchunkname_or_guid)
TrackEnvelope GetTrackEnvelopeByChunkName(MediaTrack tr, "cfgchunkname_or_guid")
TrackEnvelope reaper.GetTrackEnvelopeByChunkName(MediaTrack tr, string cfgchunkname_or_guid)
TrackEnvelope RPR_GetTrackEnvelopeByChunkName(MediaTrack tr, String cfgchunkname_or_guid)

Gets a built-in track envelope by configuration chunk name, like "<VOLENV", or GUID string, like "{B577250D-146F-B544-9B34-F24FBE488F1F}".

TrackEnvelope* GetTrackEnvelopeByName(MediaTrack* track, const char* envname)
TrackEnvelope GetTrackEnvelopeByName(MediaTrack track, "envname")
TrackEnvelope reaper.GetTrackEnvelopeByName(MediaTrack track, string envname)
TrackEnvelope RPR_GetTrackEnvelopeByName(MediaTrack track, String envname)
MediaTrack* GetTrackFromPoint(int screen_x, int screen_y, int* infoOutOptional)
MediaTrack GetTrackFromPoint(int screen_x, int screen_y, optional int &info)
MediaTrack retval, optional integer info = reaper.GetTrackFromPoint(integer screen_x, integer screen_y)
(MediaTrack retval, Int screen_x, Int screen_y, Int infoOutOptional) = RPR_GetTrackFromPoint(screen_x, screen_y, infoOutOptional)

Returns the track from the screen coordinates specified. If the screen coordinates refer to a window associated to the track (such as FX), the track will be returned. infoOutOptional will be set to 1 if it is likely an envelope, 2 if it is likely a track FX. For a free item positioning or fixed lane track, the second byte of infoOutOptional will be set to the (approximate, for fipm tracks) item lane underneath the mouse. See GetThingFromPoint.

GUID* GetTrackGUID(MediaTrack* tr)
bool GetTrackGUID(#retguid, MediaTrack tr)
string GUID = reaper.GetTrackGUID(MediaTrack tr)
GUID RPR_GetTrackGUID(MediaTrack tr)
MediaItem* GetTrackMediaItem(MediaTrack* tr, int itemidx)
MediaItem GetTrackMediaItem(MediaTrack tr, int itemidx)
MediaItem reaper.GetTrackMediaItem(MediaTrack tr, integer itemidx)
MediaItem RPR_GetTrackMediaItem(MediaTrack tr, Int itemidx)
bool GetTrackMIDILyrics(MediaTrack* track, int flag, char* bufOutWantNeedBig, int* bufOutWantNeedBig_sz)
bool GetTrackMIDILyrics(MediaTrack track, int flag, #buf)
boolean retval, string buf = reaper.GetTrackMIDILyrics(MediaTrack track, integer flag)
(Boolean retval, MediaTrack track, Int flag, String bufOutWantNeedBig, Int bufOutWantNeedBig_sz) = RPR_GetTrackMIDILyrics(track, flag, bufOutWantNeedBig, bufOutWantNeedBig_sz)

Get all MIDI lyrics on the track. Lyrics will be returned as one string with tabs between each word. flag&1: double tabs at the end of each measure and triple tabs when skipping measures, flag&2: each lyric is preceded by its beat position in the project (example with flag=2: "1.1.2\tLyric for measure 1 beat 2\t2.1.1\tLyric for measure 2 beat 1 "). See SetTrackMIDILyrics

const char* GetTrackMIDINoteName(int track, int pitch, int chan)
bool GetTrackMIDINoteName(#retval, int track, int pitch, int chan)
string reaper.GetTrackMIDINoteName(integer track, integer pitch, integer chan)
String RPR_GetTrackMIDINoteName(Int track, Int pitch, Int chan)

see GetTrackMIDINoteNameEx

const char* GetTrackMIDINoteNameEx(ReaProject* proj, MediaTrack* track, int pitch, int chan)
bool GetTrackMIDINoteNameEx(#retval, ReaProject proj, MediaTrack track, int pitch, int chan)
string reaper.GetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, integer pitch, integer chan)
String RPR_GetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, Int pitch, Int chan)

Get note/CC name. pitch 128 for CC0 name, 129 for CC1 name, etc. See SetTrackMIDINoteNameEx

void GetTrackMIDINoteRange(ReaProject* proj, MediaTrack* track, int* note_loOut, int* note_hiOut)
GetTrackMIDINoteRange(ReaProject proj, MediaTrack track, int &note_lo, int &note_hi)
integer note_lo, integer note_hi = reaper.GetTrackMIDINoteRange(ReaProject proj, MediaTrack track)
(ReaProject proj, MediaTrack track, Int note_loOut, Int note_hiOut) = RPR_GetTrackMIDINoteRange(proj, track, note_loOut, note_hiOut)
bool GetTrackName(MediaTrack* track, char* bufOut, int bufOut_sz)
bool GetTrackName(MediaTrack track, #buf)
boolean retval, string buf = reaper.GetTrackName(MediaTrack track)
(Boolean retval, MediaTrack track, String bufOut, Int bufOut_sz) = RPR_GetTrackName(track, bufOut, bufOut_sz)

Returns "MASTER" for master track, "Track N" if track has no name.

int GetTrackNumMediaItems(MediaTrack* tr)
int GetTrackNumMediaItems(MediaTrack tr)
integer reaper.GetTrackNumMediaItems(MediaTrack tr)
Int RPR_GetTrackNumMediaItems(MediaTrack tr)
int GetTrackNumSends(MediaTrack* tr, int category)
int GetTrackNumSends(MediaTrack tr, int category)
integer reaper.GetTrackNumSends(MediaTrack tr, integer category)
Int RPR_GetTrackNumSends(MediaTrack tr, Int category)

returns number of sends/receives/hardware outputs - category is <0 for receives, 0=sends, >0 for hardware outputs

bool GetTrackReceiveName(MediaTrack* track, int recv_index, char* bufOut, int bufOut_sz)
bool GetTrackReceiveName(MediaTrack track, int recv_index, #buf)
boolean retval, string buf = reaper.GetTrackReceiveName(MediaTrack track, integer recv_index)
(Boolean retval, MediaTrack track, Int recv_index, String bufOut, Int bufOut_sz) = RPR_GetTrackReceiveName(track, recv_index, bufOut, bufOut_sz)

See GetTrackSendName.

bool GetTrackReceiveUIMute(MediaTrack* track, int recv_index, bool* muteOut)
bool GetTrackReceiveUIMute(MediaTrack track, int recv_index, bool &mute)
boolean retval, boolean mute = reaper.GetTrackReceiveUIMute(MediaTrack track, integer recv_index)
(Boolean retval, MediaTrack track, Int recv_index, Boolean muteOut) = RPR_GetTrackReceiveUIMute(track, recv_index, muteOut)

See GetTrackSendUIMute.

bool GetTrackReceiveUIVolPan(MediaTrack* track, int recv_index, double* volumeOut, double* panOut)
bool GetTrackReceiveUIVolPan(MediaTrack track, int recv_index, &volume, &pan)
boolean retval, number volume, number pan = reaper.GetTrackReceiveUIVolPan(MediaTrack track, integer recv_index)
(Boolean retval, MediaTrack track, Int recv_index, Float volumeOut, Float panOut) = RPR_GetTrackReceiveUIVolPan(track, recv_index, volumeOut, panOut)

See GetTrackSendUIVolPan.

double GetTrackSendInfo_Value(MediaTrack* tr, int category, int sendidx, const char* parmname)
double GetTrackSendInfo_Value(MediaTrack tr, int category, int sendidx, "parmname")
number reaper.GetTrackSendInfo_Value(MediaTrack tr, integer category, integer sendidx, string parmname)
Float RPR_GetTrackSendInfo_Value(MediaTrack tr, Int category, Int sendidx, String parmname)

Get send/receive/hardware output numerical-value attributes.
category is <0 for receives, 0=sends, >0 for hardware outputs
parameter names:
B_MUTE : bool *
B_PHASE : bool * : true to flip phase
B_MONO : bool *
D_VOL : double * : 1.0 = +0dB etc
D_PAN : double * : -1..+1
D_PANLAW : double * : 1.0=+0.0db, 0.5=-6dB, -1.0 = projdef etc
I_SENDMODE : int * : 0=post-fader, 1=pre-fx, 2=post-fx (deprecated), 3=post-fx
I_AUTOMODE : int * : automation mode (-1=use track automode, 0=trim/off, 1=read, 2=touch, 3=write, 4=latch)
I_SRCCHAN : int * : -1 for no audio send. Low 10 bits specify channel offset, and higher bits specify channel count. (srcchan>>10) == 0 for stereo, 1 for mono, 2 for 4 channel, 3 for 6 channel, etc.
I_DSTCHAN : int * : low 10 bits are destination index, &1024 set to mix to mono.
I_MIDIFLAGS : int * : low 5 bits=source channel 0=all, 1-16, 31=MIDI send disabled, next 5 bits=dest channel, 0=orig, 1-16=chan. &1024 for faders-send MIDI vol/pan. (>>14)&255 = src bus (0 for all, 1 for normal, 2+). (>>22)&255=destination bus (0 for all, 1 for normal, 2+)
P_DESTTRACK : MediaTrack * : destination track, only applies for sends/recvs (read-only)
P_SRCTRACK : MediaTrack * : source track, only applies for sends/recvs (read-only)
P_ENV:<envchunkname : TrackEnvelope * : call with :<VOLENV, :<PANENV, etc appended (read-only)
See CreateTrackSend, RemoveTrackSend, GetTrackNumSends.

bool GetTrackSendName(MediaTrack* track, int send_index, char* bufOut, int bufOut_sz)
bool GetTrackSendName(MediaTrack track, int send_index, #buf)
boolean retval, string buf = reaper.GetTrackSendName(MediaTrack track, integer send_index)
(Boolean retval, MediaTrack track, Int send_index, String bufOut, Int bufOut_sz) = RPR_GetTrackSendName(track, send_index, bufOut, bufOut_sz)

send_idx>=0 for hw ouputs, >=nb_of_hw_ouputs for sends. See GetTrackReceiveName.

bool GetTrackSendUIMute(MediaTrack* track, int send_index, bool* muteOut)
bool GetTrackSendUIMute(MediaTrack track, int send_index, bool &mute)
boolean retval, boolean mute = reaper.GetTrackSendUIMute(MediaTrack track, integer send_index)
(Boolean retval, MediaTrack track, Int send_index, Boolean muteOut) = RPR_GetTrackSendUIMute(track, send_index, muteOut)

send_idx>=0 for hw ouputs, >=nb_of_hw_ouputs for sends. See GetTrackReceiveUIMute.

bool GetTrackSendUIVolPan(MediaTrack* track, int send_index, double* volumeOut, double* panOut)
bool GetTrackSendUIVolPan(MediaTrack track, int send_index, &volume, &pan)
boolean retval, number volume, number pan = reaper.GetTrackSendUIVolPan(MediaTrack track, integer send_index)
(Boolean retval, MediaTrack track, Int send_index, Float volumeOut, Float panOut) = RPR_GetTrackSendUIVolPan(track, send_index, volumeOut, panOut)

send_idx>=0 for hw ouputs, >=nb_of_hw_ouputs for sends. See GetTrackReceiveUIVolPan.

const char* GetTrackState(MediaTrack* track, int* flagsOut)
bool GetTrackState(#retval, MediaTrack track, int &flags)
string retval, integer flags = reaper.GetTrackState(MediaTrack track)
(String retval, MediaTrack track, Int flagsOut) = RPR_GetTrackState(track, flagsOut)

Gets track state, returns track name.
flags will be set to:
&1=folder
&2=selected
&4=has fx enabled
&8=muted
&16=soloed
&32=SIP'd (with &16)
&64=rec armed
&128=rec monitoring on
&256=rec monitoring auto
&512=hide from TCP
&1024=hide from MCP

bool GetTrackStateChunk(MediaTrack* track, char* strNeedBig, int strNeedBig_sz, bool isundoOptional)
bool GetTrackStateChunk(MediaTrack track, #str, bool isundo)
boolean retval, string str = reaper.GetTrackStateChunk(MediaTrack track, string str, boolean isundo)
(Boolean retval, MediaTrack track, String strNeedBig, Int strNeedBig_sz, Boolean isundoOptional) = RPR_GetTrackStateChunk(track, strNeedBig, strNeedBig_sz, isundoOptional)

Gets the RPPXML state of a track, returns true if successful. Undo flag is a performance/caching hint.

bool GetTrackUIMute(MediaTrack* track, bool* muteOut)
bool GetTrackUIMute(MediaTrack track, bool &mute)
boolean retval, boolean mute = reaper.GetTrackUIMute(MediaTrack track)
(Boolean retval, MediaTrack track, Boolean muteOut) = RPR_GetTrackUIMute(track, muteOut)
bool GetTrackUIPan(MediaTrack* track, double* pan1Out, double* pan2Out, int* panmodeOut)
bool GetTrackUIPan(MediaTrack track, &pan1, &pan2, int &panmode)
boolean retval, number pan1, number pan2, integer panmode = reaper.GetTrackUIPan(MediaTrack track)
(Boolean retval, MediaTrack track, Float pan1Out, Float pan2Out, Int panmodeOut) = RPR_GetTrackUIPan(track, pan1Out, pan2Out, panmodeOut)
bool GetTrackUIVolPan(MediaTrack* track, double* volumeOut, double* panOut)
bool GetTrackUIVolPan(MediaTrack track, &volume, &pan)
boolean retval, number volume, number pan = reaper.GetTrackUIVolPan(MediaTrack track)
(Boolean retval, MediaTrack track, Float volumeOut, Float panOut) = RPR_GetTrackUIVolPan(track, volumeOut, panOut)
void GetUnderrunTime(unsigned int* audio_xrunOut, unsigned int* media_xrunOut, unsigned int* curtimeOut)
GetUnderrunTime(unsigned int &audio_xrun, unsigned int &media_xrun, unsigned int &curtime)
integer audio_xrun, integer media_xrun, integer curtime = reaper.GetUnderrunTime()
RPR_GetUnderrunTime(unsigned int audio_xrunOut, unsigned int media_xrunOut, unsigned int curtimeOut)

retrieves the last timestamps of audio xrun (yellow-flash, if available), media xrun (red-flash), and the current time stamp (all milliseconds)

bool GetUserFileNameForRead(char* filenameNeed4096, const char* title, const char* defext)
bool GetUserFileNameForRead(#filenameNeed4096, "title", "defext")
boolean retval, string filenameNeed4096 = reaper.GetUserFileNameForRead(string filenameNeed4096, string title, string defext)
(Boolean retval, String filenameNeed4096, String title, String defext) = RPR_GetUserFileNameForRead(filenameNeed4096, title, defext)

returns true if the user selected a valid file, false if the user canceled the dialog

bool GetUserInputs(const char* title, int num_inputs, const char* captions_csv, char* retvals_csv, int retvals_csv_sz)
bool GetUserInputs("title", int num_inputs, "captions_csv", #retvals_csv)
boolean retval, string retvals_csv = reaper.GetUserInputs(string title, integer num_inputs, string captions_csv, string retvals_csv)
(Boolean retval, String title, Int num_inputs, String captions_csv, String retvals_csv, Int retvals_csv_sz) = RPR_GetUserInputs(title, num_inputs, captions_csv, retvals_csv, retvals_csv_sz)

Get values from the user.
If a caption begins with *, for example "*password", the edit field will not display the input text.
Maximum fields is 16. Values are returned as a comma-separated string. Returns false if the user canceled the dialog. You can supply special extra information via additional caption fields: extrawidth=XXX to increase text field width, separator=X to use a different separator for returned fields.

void GoToMarker(ReaProject* proj, int marker_index, bool use_timeline_order)
GoToMarker(ReaProject proj, int marker_index, bool use_timeline_order)
reaper.GoToMarker(ReaProject proj, integer marker_index, boolean use_timeline_order)
RPR_GoToMarker(ReaProject proj, Int marker_index, Boolean use_timeline_order)

Go to marker. If use_timeline_order==true, marker_index 1 refers to the first marker on the timeline. If use_timeline_order==false, marker_index 1 refers to the first marker with the user-editable index of 1.

void GoToRegion(ReaProject* proj, int region_index, bool use_timeline_order)
GoToRegion(ReaProject proj, int region_index, bool use_timeline_order)
reaper.GoToRegion(ReaProject proj, integer region_index, boolean use_timeline_order)
RPR_GoToRegion(ReaProject proj, Int region_index, Boolean use_timeline_order)

Seek to region after current region finishes playing (smooth seek). If use_timeline_order==true, region_index 1 refers to the first region on the timeline. If use_timeline_order==false, region_index 1 refers to the first region with the user-editable index of 1.

int GR_SelectColor(HWND hwnd, int* colorOut)
int GR_SelectColor(HWND hwnd, int &color)
integer retval, integer color = reaper.GR_SelectColor(HWND hwnd)
(Int retval, HWND hwnd, Int colorOut) = RPR_GR_SelectColor(hwnd, colorOut)

Runs the system color chooser dialog. Returns 0 if the user cancels the dialog.

int GSC_mainwnd(int t)
int GSC_mainwnd(int t)
integer reaper.GSC_mainwnd(integer t)
Int RPR_GSC_mainwnd(Int t)

this is just like win32 GetSysColor() but can have overrides.

void guidToString(const GUID* g, char* destNeed64)
guidToString("gGUID", #destNeed64)
string destNeed64 = reaper.guidToString(string gGUID, string destNeed64)
(const GUID g, String destNeed64) = RPR_guidToString(g, destNeed64)

dest should be at least 64 chars long to be safe

bool HasExtState(const char* section, const char* key)
bool HasExtState("section", "key")
boolean reaper.HasExtState(string section, string key)
Boolean RPR_HasExtState(String section, String key)

Returns true if there exists an extended state value for a specific section and key. See SetExtState, GetExtState, DeleteExtState.

const char* HasTrackMIDIPrograms(int track)
bool HasTrackMIDIPrograms(#retval, int track)
string reaper.HasTrackMIDIPrograms(integer track)
String RPR_HasTrackMIDIPrograms(Int track)

returns name of track plugin that is supplying MIDI programs,or NULL if there is none

const char* HasTrackMIDIProgramsEx(ReaProject* proj, MediaTrack* track)
bool HasTrackMIDIProgramsEx(#retval, ReaProject proj, MediaTrack track)
string reaper.HasTrackMIDIProgramsEx(ReaProject proj, MediaTrack track)
String RPR_HasTrackMIDIProgramsEx(ReaProject proj, MediaTrack track)

returns name of track plugin that is supplying MIDI programs,or NULL if there is none

void Help_Set(const char* helpstring, bool is_temporary_help)
Help_Set("helpstring", bool is_temporary_help)
reaper.Help_Set(string helpstring, boolean is_temporary_help)
RPR_Help_Set(String helpstring, Boolean is_temporary_help)
void image_resolve_fn(const char* in, char* out, int out_sz)
image_resolve_fn("in", #out)
string out = reaper.image_resolve_fn(string in, string out)
(String in, String out, Int out_sz) = RPR_image_resolve_fn(in, out, out_sz)
int InsertAutomationItem(TrackEnvelope* env, int pool_id, double position, double length)
int InsertAutomationItem(TrackEnvelope env, int pool_id, position, length)
integer reaper.InsertAutomationItem(TrackEnvelope env, integer pool_id, number position, number length)
Int RPR_InsertAutomationItem(TrackEnvelope env, Int pool_id, Float position, Float length)

Insert a new automation item. pool_id < 0 collects existing envelope points into the automation item; if pool_id is >= 0 the automation item will be a new instance of that pool (which will be created as an empty instance if it does not exist). Returns the index of the item, suitable for passing to other automation item API functions. See GetSetAutomationItemInfo.

bool InsertEnvelopePoint(TrackEnvelope* envelope, double time, double value, int shape, double tension, bool selected, bool* noSortInOptional)
bool InsertEnvelopePoint(TrackEnvelope envelope, time, value, int shape, tension, bool selected, optional bool noSortIn)
boolean reaper.InsertEnvelopePoint(TrackEnvelope envelope, number time, number value, integer shape, number tension, boolean selected, optional boolean noSortIn)
(Boolean retval, TrackEnvelope envelope, Float time, Float value, Int shape, Float tension, Boolean selected, Boolean noSortInOptional) = RPR_InsertEnvelopePoint(envelope, time, value, shape, tension, selected, noSortInOptional)

Insert an envelope point. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done. See InsertEnvelopePointEx.

bool InsertEnvelopePointEx(TrackEnvelope* envelope, int autoitem_idx, double time, double value, int shape, double tension, bool selected, bool* noSortInOptional)
bool InsertEnvelopePointEx(TrackEnvelope envelope, int autoitem_idx, time, value, int shape, tension, bool selected, optional bool noSortIn)
boolean reaper.InsertEnvelopePointEx(TrackEnvelope envelope, integer autoitem_idx, number time, number value, integer shape, number tension, boolean selected, optional boolean noSortIn)
(Boolean retval, TrackEnvelope envelope, Int autoitem_idx, Float time, Float value, Int shape, Float tension, Boolean selected, Boolean noSortInOptional) = RPR_InsertEnvelopePointEx(envelope, autoitem_idx, time, value, shape, tension, selected, noSortInOptional)

Insert an envelope point. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See CountEnvelopePointsEx, GetEnvelopePointEx, SetEnvelopePointEx, DeleteEnvelopePointEx.

int InsertMedia(const char* file, int mode)
int InsertMedia("file", int mode)
integer reaper.InsertMedia(string file, integer mode)
Int RPR_InsertMedia(String file, Int mode)

mode: 0=add to current track, 1=add new track, 3=add to selected items as takes, &4=stretch/loop to fit time sel, &8=try to match tempo 1x, &16=try to match tempo 0.5x, &32=try to match tempo 2x, &64=don't preserve pitch when matching tempo, &128=no loop/section if startpct/endpct set, &256=force loop regardless of global preference for looping imported items, &512=use high word as absolute track index if mode&3==0 or mode&2048, &1024=insert into reasamplomatic on a new track (add 1 to insert on last selected track), &2048=insert into open reasamplomatic instance (add 512 to use high word as absolute track index), &4096=move to source preferred position (BWF start offset), &8192=reverse

int InsertMediaSection(const char* file, int mode, double startpct, double endpct, double pitchshift)
int InsertMediaSection("file", int mode, startpct, endpct, pitchshift)
integer reaper.InsertMediaSection(string file, integer mode, number startpct, number endpct, number pitchshift)
Int RPR_InsertMediaSection(String file, Int mode, Float startpct, Float endpct, Float pitchshift)

See InsertMedia.

void InsertTrackAtIndex(int idx, bool wantDefaults)
InsertTrackAtIndex(int idx, bool wantDefaults)
reaper.InsertTrackAtIndex(integer idx, boolean wantDefaults)
RPR_InsertTrackAtIndex(Int idx, Boolean wantDefaults)

inserts a track at idx,of course this will be clamped to 0..GetNumTracks(). wantDefaults=TRUE for default envelopes/FX,otherwise no enabled fx/env

bool IsMediaExtension(const char* ext, bool wantOthers)
bool IsMediaExtension("ext", bool wantOthers)
boolean reaper.IsMediaExtension(string ext, boolean wantOthers)
Boolean RPR_IsMediaExtension(String ext, Boolean wantOthers)

Tests a file extension (i.e. "wav" or "mid") to see if it's a media extension.
If wantOthers is set, then "RPP", "TXT" and other project-type formats will also pass.

bool IsMediaItemSelected(MediaItem* item)
bool IsMediaItemSelected(MediaItem item)
boolean reaper.IsMediaItemSelected(MediaItem item)
Boolean RPR_IsMediaItemSelected(MediaItem item)
int IsProjectDirty(ReaProject* proj)
int IsProjectDirty(ReaProject proj)
integer reaper.IsProjectDirty(ReaProject proj)
Int RPR_IsProjectDirty(ReaProject proj)

Is the project dirty (needing save)? Always returns 0 if 'undo/prompt to save' is disabled in preferences.

bool IsTrackSelected(MediaTrack* track)
bool IsTrackSelected(MediaTrack track)
boolean reaper.IsTrackSelected(MediaTrack track)
Boolean RPR_IsTrackSelected(MediaTrack track)
bool IsTrackVisible(MediaTrack* track, bool mixer)
bool IsTrackVisible(MediaTrack track, bool mixer)
boolean reaper.IsTrackVisible(MediaTrack track, boolean mixer)
Boolean RPR_IsTrackVisible(MediaTrack track, Boolean mixer)

If mixer==true, returns true if the track is visible in the mixer. If mixer==false, returns true if the track is visible in the track control panel.

joystick_device* joystick_create(const GUID* guid)
joystick_device joystick_create("guidGUID")
joystick_device reaper.joystick_create(string guidGUID)
joystick_device RPR_joystick_create(const GUID guid)

creates a joystick device

void joystick_destroy(joystick_device* device)
joystick_destroy(joystick_device device)
reaper.joystick_destroy(joystick_device device)
RPR_joystick_destroy(joystick_device device)

destroys a joystick device

const char* joystick_enum(int index, const char** namestrOutOptional)
bool joystick_enum(#retval, int index, optional #namestr)
string retval, optional string namestr = reaper.joystick_enum(integer index)
String RPR_joystick_enum(Int index, String namestrOutOptional)

enumerates installed devices, returns GUID as a string

double joystick_getaxis(joystick_device* dev, int axis)
double joystick_getaxis(joystick_device dev, int axis)
number reaper.joystick_getaxis(joystick_device dev, integer axis)
Float RPR_joystick_getaxis(joystick_device dev, Int axis)

returns axis value (-1..1)

unsigned int joystick_getbuttonmask(joystick_device* dev)
uint joystick_getbuttonmask(joystick_device dev)
integer reaper.joystick_getbuttonmask(joystick_device dev)
Unknown RPR_joystick_getbuttonmask(joystick_device dev)

returns button pressed mask, 1=first button, 2=second...

int joystick_getinfo(joystick_device* dev, int* axesOutOptional, int* povsOutOptional)
int joystick_getinfo(joystick_device dev, optional int &axes, optional int &povs)
integer retval, optional integer axes, optional integer povs = reaper.joystick_getinfo(joystick_device dev)
(Int retval, joystick_device dev, Int axesOutOptional, Int povsOutOptional) = RPR_joystick_getinfo(dev, axesOutOptional, povsOutOptional)

returns button count

double joystick_getpov(joystick_device* dev, int pov)
double joystick_getpov(joystick_device dev, int pov)
number reaper.joystick_getpov(joystick_device dev, integer pov)
Float RPR_joystick_getpov(joystick_device dev, Int pov)

returns POV value (usually 0..655.35, or 655.35 on error)

bool joystick_update(joystick_device* dev)
bool joystick_update(joystick_device dev)
boolean reaper.joystick_update(joystick_device dev)
Boolean RPR_joystick_update(joystick_device dev)

Updates joystick state from hardware, returns true if successful (joystick_get* will not be valid until joystick_update() is called successfully)

int kbd_enumerateActions(KbdSectionInfo* section, int idx, const char** nameOut)
int kbd_enumerateActions(KbdSectionInfo section, int idx, #name)
integer retval, string name = reaper.kbd_enumerateActions(KbdSectionInfo section, integer idx)
Int RPR_kbd_enumerateActions(KbdSectionInfo section, Int idx, String nameOut)
const char* kbd_getTextFromCmd(int cmd, KbdSectionInfo* section)
bool kbd_getTextFromCmd(#retval, int cmd, KbdSectionInfo section)
string reaper.kbd_getTextFromCmd(integer cmd, KbdSectionInfo section)
String RPR_kbd_getTextFromCmd(Int cmd, KbdSectionInfo section)
bool LICE_ClipLine(int* pX1Out, int* pY1Out, int* pX2Out, int* pY2Out, int xLo, int yLo, int xHi, int yHi)
bool LICE_ClipLine(int &pX1, int &pY1, int &pX2, int &pY2, int xLo, int yLo, int xHi, int yHi)
boolean retval, integer pX1, integer pY1, integer pX2, integer pY2 = reaper.LICE_ClipLine(integer pX1, integer pY1, integer pX2, integer pY2, integer xLo, integer yLo, integer xHi, integer yHi)
(Boolean retval, Int pX1Out, Int pY1Out, Int pX2Out, Int pY2Out, Int xLo, Int yLo, Int xHi, Int yHi) = RPR_LICE_ClipLine(pX1Out, pY1Out, pX2Out, pY2Out, xLo, yLo, xHi, yHi)

Returns false if the line is entirely offscreen.

const char* LocalizeString(const char* src_string, const char* section, int flagsOptional)
bool LocalizeString(#retval, "src_string", "section", int flags)
string reaper.LocalizeString(string src_string, string section, integer flags)
String RPR_LocalizeString(String src_string, String section, Int flagsOptional)

Returns a localized version of src_string, in section section. flags can have 1 set to only localize if sprintf-style formatting matches the original.

bool Loop_OnArrow(ReaProject* project, int direction)
bool Loop_OnArrow(ReaProject project, int direction)
boolean reaper.Loop_OnArrow(ReaProject project, integer direction)
Boolean RPR_Loop_OnArrow(ReaProject project, Int direction)

Move the loop selection left or right. Returns true if snap is enabled.

void Main_OnCommand(int command, int flag)
Main_OnCommand(int command, int flag)
reaper.Main_OnCommand(integer command, integer flag)
RPR_Main_OnCommand(Int command, Int flag)

See Main_OnCommandEx.

void Main_OnCommandEx(int command, int flag, ReaProject* proj)
Main_OnCommandEx(int command, int flag, ReaProject proj)
reaper.Main_OnCommandEx(integer command, integer flag, ReaProject proj)
RPR_Main_OnCommandEx(Int command, Int flag, ReaProject proj)

Performs an action belonging to the main action section. To perform non-native actions (ReaScripts, custom or extension plugins' actions) safely, see NamedCommandLookup().

void Main_openProject(const char* name)
Main_openProject("name")
reaper.Main_openProject(string name)
RPR_Main_openProject(String name)

opens a project. will prompt the user to save unless name is prefixed with 'noprompt:'. If name is prefixed with 'template:', project file will be loaded as a template.
If passed a .RTrackTemplate file, adds the template to the existing project.

void Main_SaveProject(ReaProject* proj, bool forceSaveAsInOptional)
Main_SaveProject(ReaProject proj, bool forceSaveAsIn)
reaper.Main_SaveProject(ReaProject proj, boolean forceSaveAsIn)
RPR_Main_SaveProject(ReaProject proj, Boolean forceSaveAsInOptional)

Save the project.

void Main_SaveProjectEx(ReaProject* proj, const char* filename, int options)
Main_SaveProjectEx(ReaProject proj, "filename", int options)
reaper.Main_SaveProjectEx(ReaProject proj, string filename, integer options)
RPR_Main_SaveProjectEx(ReaProject proj, String filename, Int options)

Save the project. options: &1=save selected tracks as track template, &2=include media with track template, &4=include envelopes with track template. See Main_openProject, Main_SaveProject.

void Main_UpdateLoopInfo(int ignoremask)
Main_UpdateLoopInfo(int ignoremask)
reaper.Main_UpdateLoopInfo(integer ignoremask)
RPR_Main_UpdateLoopInfo(Int ignoremask)
void MarkProjectDirty(ReaProject* proj)
MarkProjectDirty(ReaProject proj)
reaper.MarkProjectDirty(ReaProject proj)
RPR_MarkProjectDirty(ReaProject proj)

Marks project as dirty (needing save) if 'undo/prompt to save' is enabled in preferences.

void MarkTrackItemsDirty(MediaTrack* track, MediaItem* item)
MarkTrackItemsDirty(MediaTrack track, MediaItem item)
reaper.MarkTrackItemsDirty(MediaTrack track, MediaItem item)
RPR_MarkTrackItemsDirty(MediaTrack track, MediaItem item)

If track is supplied, item is ignored

double Master_GetPlayRate(ReaProject* project)
double Master_GetPlayRate(ReaProject project)
number reaper.Master_GetPlayRate(ReaProject project)
Float RPR_Master_GetPlayRate(ReaProject project)
double Master_GetPlayRateAtTime(double time_s, ReaProject* proj)
double Master_GetPlayRateAtTime(time_s, ReaProject proj)
number reaper.Master_GetPlayRateAtTime(number time_s, ReaProject proj)
Float RPR_Master_GetPlayRateAtTime(Float time_s, ReaProject proj)
double Master_GetTempo()
double Master_GetTempo()
number reaper.Master_GetTempo()
Float RPR_Master_GetTempo()
double Master_NormalizePlayRate(double playrate, bool isnormalized)
double Master_NormalizePlayRate(playrate, bool isnormalized)
number reaper.Master_NormalizePlayRate(number playrate, boolean isnormalized)
Float RPR_Master_NormalizePlayRate(Float playrate, Boolean isnormalized)

Convert play rate to/from a value between 0 and 1, representing the position on the project playrate slider.

double Master_NormalizeTempo(double bpm, bool isnormalized)
double Master_NormalizeTempo(bpm, bool isnormalized)
number reaper.Master_NormalizeTempo(number bpm, boolean isnormalized)
Float RPR_Master_NormalizeTempo(Float bpm, Boolean isnormalized)

Convert the tempo to/from a value between 0 and 1, representing bpm in the range of 40-296 bpm.

int MB(const char* msg, const char* title, int type)
int MB("msg", "title", int type)
integer reaper.MB(string msg, string title, integer type)
Int RPR_MB(String msg, String title, Int type)

type 0=OK,1=OKCANCEL,2=ABORTRETRYIGNORE,3=YESNOCANCEL,4=YESNO,5=RETRYCANCEL : ret 1=OK,2=CANCEL,3=ABORT,4=RETRY,5=IGNORE,6=YES,7=NO

int MediaItemDescendsFromTrack(MediaItem* item, MediaTrack* track)
int MediaItemDescendsFromTrack(MediaItem item, MediaTrack track)
integer reaper.MediaItemDescendsFromTrack(MediaItem item, MediaTrack track)
Int RPR_MediaItemDescendsFromTrack(MediaItem item, MediaTrack track)

Returns 1 if the track holds the item, 2 if the track is a folder containing the track that holds the item, etc.

int MIDI_CountEvts(MediaItem_Take* take, int* notecntOut, int* ccevtcntOut, int* textsyxevtcntOut)
int MIDI_CountEvts(MediaItem_Take take, int &notecnt, int &ccevtcnt, int &textsyxevtcnt)
integer retval, integer notecnt, integer ccevtcnt, integer textsyxevtcnt = reaper.MIDI_CountEvts(MediaItem_Take take)
(Int retval, MediaItem_Take take, Int notecntOut, Int ccevtcntOut, Int textsyxevtcntOut) = RPR_MIDI_CountEvts(take, notecntOut, ccevtcntOut, textsyxevtcntOut)

Count the number of notes, CC events, and text/sysex events in a given MIDI item.

bool MIDI_DeleteCC(MediaItem_Take* take, int ccidx)
bool MIDI_DeleteCC(MediaItem_Take take, int ccidx)
boolean reaper.MIDI_DeleteCC(MediaItem_Take take, integer ccidx)
Boolean RPR_MIDI_DeleteCC(MediaItem_Take take, Int ccidx)

Delete a MIDI CC event.

bool MIDI_DeleteEvt(MediaItem_Take* take, int evtidx)
bool MIDI_DeleteEvt(MediaItem_Take take, int evtidx)
boolean reaper.MIDI_DeleteEvt(MediaItem_Take take, integer evtidx)
Boolean RPR_MIDI_DeleteEvt(MediaItem_Take take, Int evtidx)

Delete a MIDI event.

bool MIDI_DeleteNote(MediaItem_Take* take, int noteidx)
bool MIDI_DeleteNote(MediaItem_Take take, int noteidx)
boolean reaper.MIDI_DeleteNote(MediaItem_Take take, integer noteidx)
Boolean RPR_MIDI_DeleteNote(MediaItem_Take take, Int noteidx)

Delete a MIDI note.

bool MIDI_DeleteTextSysexEvt(MediaItem_Take* take, int textsyxevtidx)
bool MIDI_DeleteTextSysexEvt(MediaItem_Take take, int textsyxevtidx)
boolean reaper.MIDI_DeleteTextSysexEvt(MediaItem_Take take, integer textsyxevtidx)
Boolean RPR_MIDI_DeleteTextSysexEvt(MediaItem_Take take, Int textsyxevtidx)

Delete a MIDI text or sysex event.

void MIDI_DisableSort(MediaItem_Take* take)
MIDI_DisableSort(MediaItem_Take take)
reaper.MIDI_DisableSort(MediaItem_Take take)
RPR_MIDI_DisableSort(MediaItem_Take take)

Disable sorting for all MIDI insert, delete, get and set functions, until MIDI_Sort is called.

int MIDI_EnumSelCC(MediaItem_Take* take, int ccidx)
int MIDI_EnumSelCC(MediaItem_Take take, int ccidx)
integer reaper.MIDI_EnumSelCC(MediaItem_Take take, integer ccidx)
Int RPR_MIDI_EnumSelCC(MediaItem_Take take, Int ccidx)

Returns the index of the next selected MIDI CC event after ccidx (-1 if there are no more selected events).

int MIDI_EnumSelEvts(MediaItem_Take* take, int evtidx)
int MIDI_EnumSelEvts(MediaItem_Take take, int evtidx)
integer reaper.MIDI_EnumSelEvts(MediaItem_Take take, integer evtidx)
Int RPR_MIDI_EnumSelEvts(MediaItem_Take take, Int evtidx)

Returns the index of the next selected MIDI event after evtidx (-1 if there are no more selected events).

int MIDI_EnumSelNotes(MediaItem_Take* take, int noteidx)
int MIDI_EnumSelNotes(MediaItem_Take take, int noteidx)
integer reaper.MIDI_EnumSelNotes(MediaItem_Take take, integer noteidx)
Int RPR_MIDI_EnumSelNotes(MediaItem_Take take, Int noteidx)

Returns the index of the next selected MIDI note after noteidx (-1 if there are no more selected events).

int MIDI_EnumSelTextSysexEvts(MediaItem_Take* take, int textsyxidx)
int MIDI_EnumSelTextSysexEvts(MediaItem_Take take, int textsyxidx)
integer reaper.MIDI_EnumSelTextSysexEvts(MediaItem_Take take, integer textsyxidx)
Int RPR_MIDI_EnumSelTextSysexEvts(MediaItem_Take take, Int textsyxidx)

Returns the index of the next selected MIDI text/sysex event after textsyxidx (-1 if there are no more selected events).

bool MIDI_GetAllEvts(MediaItem_Take* take, char* bufOutNeedBig, int* bufOutNeedBig_sz)
bool MIDI_GetAllEvts(MediaItem_Take take, #buf)
boolean retval, string buf = reaper.MIDI_GetAllEvts(MediaItem_Take take)
(Boolean retval, MediaItem_Take take, String bufOutNeedBig, Int bufOutNeedBig_sz) = RPR_MIDI_GetAllEvts(take, bufOutNeedBig, bufOutNeedBig_sz)

Get all MIDI data. MIDI buffer is returned as a list of { int offset, char flag, int msglen, unsigned char msg[] }.
offset: MIDI ticks from previous event
flag: &1=selected &2=muted
flag high 4 bits for CC shape: &16=linear, &32=slow start/end, &16|32=fast start, &64=fast end, &64|16=bezier
msg: the MIDI message.
A meta-event of type 0xF followed by 'CCBZ ' and 5 more bytes represents bezier curve data for the previous MIDI event: 1 byte for the bezier type (usually 0) and 4 bytes for the bezier tension as a float.
For tick intervals longer than a 32 bit word can represent, zero-length meta events may be placed between valid events.
See MIDI_SetAllEvts.

bool MIDI_GetCC(MediaItem_Take* take, int ccidx, bool* selectedOut, bool* mutedOut, double* ppqposOut, int* chanmsgOut, int* chanOut, int* msg2Out, int* msg3Out)
bool MIDI_GetCC(MediaItem_Take take, int ccidx, bool &selected, bool &muted, &ppqpos, int &chanmsg, int &chan, int &msg2, int &msg3)
boolean retval, boolean selected, boolean muted, number ppqpos, integer chanmsg, integer chan, integer msg2, integer msg3 = reaper.MIDI_GetCC(MediaItem_Take take, integer ccidx)
(Boolean retval, MediaItem_Take take, Int ccidx, Boolean selectedOut, Boolean mutedOut, Float ppqposOut, Int chanmsgOut, Int chanOut, Int msg2Out, Int msg3Out) = RPR_MIDI_GetCC(take, ccidx, selectedOut, mutedOut, ppqposOut, chanmsgOut, chanOut, msg2Out, msg3Out)

Get MIDI CC event properties.

bool MIDI_GetCCShape(MediaItem_Take* take, int ccidx, int* shapeOut, double* beztensionOut)
bool MIDI_GetCCShape(MediaItem_Take take, int ccidx, int &shape, &beztension)
boolean retval, integer shape, number beztension = reaper.MIDI_GetCCShape(MediaItem_Take take, integer ccidx)
(Boolean retval, MediaItem_Take take, Int ccidx, Int shapeOut, Float beztensionOut) = RPR_MIDI_GetCCShape(take, ccidx, shapeOut, beztensionOut)

Get CC shape and bezier tension. See MIDI_GetCC, MIDI_SetCCShape

bool MIDI_GetEvt(MediaItem_Take* take, int evtidx, bool* selectedOut, bool* mutedOut, double* ppqposOut, char* msgOut, int* msgOut_sz)
bool MIDI_GetEvt(MediaItem_Take take, int evtidx, bool &selected, bool &muted, &ppqpos, #msg)
boolean retval, boolean selected, boolean muted, number ppqpos, string msg = reaper.MIDI_GetEvt(MediaItem_Take take, integer evtidx)
(Boolean retval, MediaItem_Take take, Int evtidx, Boolean selectedOut, Boolean mutedOut, Float ppqposOut, String msgOut, Int msgOut_sz) = RPR_MIDI_GetEvt(take, evtidx, selectedOut, mutedOut, ppqposOut, msgOut, msgOut_sz)

Get MIDI event properties.

double MIDI_GetGrid(MediaItem_Take* take, double* swingOutOptional, double* noteLenOutOptional)
double MIDI_GetGrid(MediaItem_Take take, optional &swing, optional &noteLen)
number retval, optional number swing, optional number noteLen = reaper.MIDI_GetGrid(MediaItem_Take take)
(Float retval, MediaItem_Take take, Float swingOutOptional, Float noteLenOutOptional) = RPR_MIDI_GetGrid(take, swingOutOptional, noteLenOutOptional)

Returns the most recent MIDI editor grid size for this MIDI take, in QN. Swing is between 0 and 1. Note length is 0 if it follows the grid size.

bool MIDI_GetHash(MediaItem_Take* take, bool notesonly, char* hashOut, int hashOut_sz)
bool MIDI_GetHash(MediaItem_Take take, bool notesonly, #hash)
boolean retval, string hash = reaper.MIDI_GetHash(MediaItem_Take take, boolean notesonly)
(Boolean retval, MediaItem_Take take, Boolean notesonly, String hashOut, Int hashOut_sz) = RPR_MIDI_GetHash(take, notesonly, hashOut, hashOut_sz)

Get a string that only changes when the MIDI data changes. If notesonly==true, then the string changes only when the MIDI notes change. See MIDI_GetTrackHash

bool MIDI_GetNote(MediaItem_Take* take, int noteidx, bool* selectedOut, bool* mutedOut, double* startppqposOut, double* endppqposOut, int* chanOut, int* pitchOut, int* velOut)
bool MIDI_GetNote(MediaItem_Take take, int noteidx, bool &selected, bool &muted, &startppqpos, &endppqpos, int &chan, int &pitch, int &vel)
boolean retval, boolean selected, boolean muted, number startppqpos, number endppqpos, integer chan, integer pitch, integer vel = reaper.MIDI_GetNote(MediaItem_Take take, integer noteidx)
(Boolean retval, MediaItem_Take take, Int noteidx, Boolean selectedOut, Boolean mutedOut, Float startppqposOut, Float endppqposOut, Int chanOut, Int pitchOut, Int velOut) = RPR_MIDI_GetNote(take, noteidx, selectedOut, mutedOut, startppqposOut, endppqposOut, chanOut, pitchOut, velOut)

Get MIDI note properties.

double MIDI_GetPPQPos_EndOfMeasure(MediaItem_Take* take, double ppqpos)
double MIDI_GetPPQPos_EndOfMeasure(MediaItem_Take take, ppqpos)
number reaper.MIDI_GetPPQPos_EndOfMeasure(MediaItem_Take take, number ppqpos)
Float RPR_MIDI_GetPPQPos_EndOfMeasure(MediaItem_Take take, Float ppqpos)

Returns the MIDI tick (ppq) position corresponding to the end of the measure.

double MIDI_GetPPQPos_StartOfMeasure(MediaItem_Take* take, double ppqpos)
double MIDI_GetPPQPos_StartOfMeasure(MediaItem_Take take, ppqpos)
number reaper.MIDI_GetPPQPos_StartOfMeasure(MediaItem_Take take, number ppqpos)
Float RPR_MIDI_GetPPQPos_StartOfMeasure(MediaItem_Take take, Float ppqpos)

Returns the MIDI tick (ppq) position corresponding to the start of the measure.

double MIDI_GetPPQPosFromProjQN(MediaItem_Take* take, double projqn)
double MIDI_GetPPQPosFromProjQN(MediaItem_Take take, projqn)
number reaper.MIDI_GetPPQPosFromProjQN(MediaItem_Take take, number projqn)
Float RPR_MIDI_GetPPQPosFromProjQN(MediaItem_Take take, Float projqn)

Returns the MIDI tick (ppq) position corresponding to a specific project time in quarter notes.

double MIDI_GetPPQPosFromProjTime(MediaItem_Take* take, double projtime)
double MIDI_GetPPQPosFromProjTime(MediaItem_Take take, projtime)
number reaper.MIDI_GetPPQPosFromProjTime(MediaItem_Take take, number projtime)
Float RPR_MIDI_GetPPQPosFromProjTime(MediaItem_Take take, Float projtime)

Returns the MIDI tick (ppq) position corresponding to a specific project time in seconds.

double MIDI_GetProjQNFromPPQPos(MediaItem_Take* take, double ppqpos)
double MIDI_GetProjQNFromPPQPos(MediaItem_Take take, ppqpos)
number reaper.MIDI_GetProjQNFromPPQPos(MediaItem_Take take, number ppqpos)
Float RPR_MIDI_GetProjQNFromPPQPos(MediaItem_Take take, Float ppqpos)

Returns the project time in quarter notes corresponding to a specific MIDI tick (ppq) position.

double MIDI_GetProjTimeFromPPQPos(MediaItem_Take* take, double ppqpos)
double MIDI_GetProjTimeFromPPQPos(MediaItem_Take take, ppqpos)
number reaper.MIDI_GetProjTimeFromPPQPos(MediaItem_Take take, number ppqpos)
Float RPR_MIDI_GetProjTimeFromPPQPos(MediaItem_Take take, Float ppqpos)

Returns the project time in seconds corresponding to a specific MIDI tick (ppq) position.

int MIDI_GetRecentInputEvent(int idx, char* bufOut, int* bufOut_sz, int* tsOut, int* devIdxOut, double* projPosOut, int* projLoopCntOut)
int MIDI_GetRecentInputEvent(int idx, #buf, int &ts, int &devIdx, &projPos, int &projLoopCnt)
integer retval, string buf, integer ts, integer devIdx, number projPos, integer projLoopCnt = reaper.MIDI_GetRecentInputEvent(integer idx)
(Int retval, Int idx, String bufOut, Int bufOut_sz, Int tsOut, Int devIdxOut, Float projPosOut, Int projLoopCntOut) = RPR_MIDI_GetRecentInputEvent(idx, bufOut, bufOut_sz, tsOut, devIdxOut, projPosOut, projLoopCntOut)

Gets a recent MIDI input event from the global history. idx=0 for the most recent event, which also latches to the latest MIDI event state (to get a more recent list, calling with idx=0 is necessary). idx=1 next most recent event, returns a non-zero sequence number for the event, or zero if no more events. tsOut will be set to the timestamp in samples relative to the current position (0 is current, -48000 is one second ago, etc). devIdxOut will have the low 16 bits set to the input device index, and 0x10000 will be set if device was enabled only for control. projPosOut will be set to project position in seconds if project was playing back at time of event, otherwise -1. Large SysEx events will not be included in this event list.

bool MIDI_GetScale(MediaItem_Take* take, int* rootOut, int* scaleOut, char* nameOut, int nameOut_sz)
bool MIDI_GetScale(MediaItem_Take take, int &root, int &scale, #name)
boolean retval, integer root, integer scale, string name = reaper.MIDI_GetScale(MediaItem_Take take)
(Boolean retval, MediaItem_Take take, Int rootOut, Int scaleOut, String nameOut, Int nameOut_sz) = RPR_MIDI_GetScale(take, rootOut, scaleOut, nameOut, nameOut_sz)

Get the active scale in the media source, if any. root 0=C, 1=C#, etc. scale &0x1=root, &0x2=minor 2nd, &0x4=major 2nd, &0x8=minor 3rd, &0xF=fourth, etc.

bool MIDI_GetTextSysexEvt(MediaItem_Take* take, int textsyxevtidx, bool* selectedOutOptional, bool* mutedOutOptional, double* ppqposOutOptional, int* typeOutOptional, char* msgOptional, int* msgOptional_sz)
bool MIDI_GetTextSysexEvt(MediaItem_Take take, int textsyxevtidx, optional bool &selected, optional bool &muted, optional &ppqpos, optional int &type, optional #msg)
boolean retval, optional boolean selected, optional boolean muted, optional number ppqpos, optional integer type, optional string msg = reaper.MIDI_GetTextSysexEvt(MediaItem_Take take, integer textsyxevtidx, optional boolean selected, optional boolean muted, optional number ppqpos, optional integer type, optional string msg)
(Boolean retval, MediaItem_Take take, Int textsyxevtidx, Boolean selectedOutOptional, Boolean mutedOutOptional, Float ppqposOutOptional, Int typeOutOptional, String msgOptional, Int msgOptional_sz) = RPR_MIDI_GetTextSysexEvt(take, textsyxevtidx, selectedOutOptional, mutedOutOptional, ppqposOutOptional, typeOutOptional, msgOptional, msgOptional_sz)

Get MIDI meta-event properties. Allowable types are -1:sysex (msg should not include bounding F0..F7), 1-14:MIDI text event types, 15=REAPER notation event. For all other meta-messages, type is returned as -2 and msg returned as all zeroes. See MIDI_GetEvt.

bool MIDI_GetTrackHash(MediaTrack* track, bool notesonly, char* hashOut, int hashOut_sz)
bool MIDI_GetTrackHash(MediaTrack track, bool notesonly, #hash)
boolean retval, string hash = reaper.MIDI_GetTrackHash(MediaTrack track, boolean notesonly)
(Boolean retval, MediaTrack track, Boolean notesonly, String hashOut, Int hashOut_sz) = RPR_MIDI_GetTrackHash(track, notesonly, hashOut, hashOut_sz)

Get a string that only changes when the MIDI data changes. If notesonly==true, then the string changes only when the MIDI notes change. See MIDI_GetHash

void midi_init(int force_reinit_input, int force_reinit_output)
midi_init(int force_reinit_input, int force_reinit_output)
reaper.midi_init(integer force_reinit_input, integer force_reinit_output)
RPR_midi_init(Int force_reinit_input, Int force_reinit_output)

Opens MIDI devices as configured in preferences. force_reinit_input and force_reinit_output force a particular device index to close/re-open (pass -1 to not force any devices to reopen).

bool MIDI_InsertCC(MediaItem_Take* take, bool selected, bool muted, double ppqpos, int chanmsg, int chan, int msg2, int msg3)
bool MIDI_InsertCC(MediaItem_Take take, bool selected, bool muted, ppqpos, int chanmsg, int chan, int msg2, int msg3)
boolean reaper.MIDI_InsertCC(MediaItem_Take take, boolean selected, boolean muted, number ppqpos, integer chanmsg, integer chan, integer msg2, integer msg3)
Boolean RPR_MIDI_InsertCC(MediaItem_Take take, Boolean selected, Boolean muted, Float ppqpos, Int chanmsg, Int chan, Int msg2, Int msg3)

Insert a new MIDI CC event.

bool MIDI_InsertEvt(MediaItem_Take* take, bool selected, bool muted, double ppqpos, const char* bytestr, int bytestr_sz)
bool MIDI_InsertEvt(MediaItem_Take take, bool selected, bool muted, ppqpos, "bytestr")
boolean reaper.MIDI_InsertEvt(MediaItem_Take take, boolean selected, boolean muted, number ppqpos, string bytestr)
Boolean RPR_MIDI_InsertEvt(MediaItem_Take take, Boolean selected, Boolean muted, Float ppqpos, String bytestr, Int bytestr_sz)

Insert a new MIDI event.

bool MIDI_InsertNote(MediaItem_Take* take, bool selected, bool muted, double startppqpos, double endppqpos, int chan, int pitch, int vel, const bool* noSortInOptional)
bool MIDI_InsertNote(MediaItem_Take take, bool selected, bool muted, startppqpos, endppqpos, int chan, int pitch, int vel, optional bool noSortIn)
boolean reaper.MIDI_InsertNote(MediaItem_Take take, boolean selected, boolean muted, number startppqpos, number endppqpos, integer chan, integer pitch, integer vel, optional boolean noSortIn)
Boolean RPR_MIDI_InsertNote(MediaItem_Take take, Boolean selected, Boolean muted, Float startppqpos, Float endppqpos, Int chan, Int pitch, Int vel, const bool noSortInOptional)

Insert a new MIDI note. Set noSort if inserting multiple events, then call MIDI_Sort when done.

bool MIDI_InsertTextSysexEvt(MediaItem_Take* take, bool selected, bool muted, double ppqpos, int type, const char* bytestr, int bytestr_sz)
bool MIDI_InsertTextSysexEvt(MediaItem_Take take, bool selected, bool muted, ppqpos, int type, "bytestr")
boolean reaper.MIDI_InsertTextSysexEvt(MediaItem_Take take, boolean selected, boolean muted, number ppqpos, integer type, string bytestr)
Boolean RPR_MIDI_InsertTextSysexEvt(MediaItem_Take take, Boolean selected, Boolean muted, Float ppqpos, Int type, String bytestr, Int bytestr_sz)

Insert a new MIDI text or sysex event. Allowable types are -1:sysex (msg should not include bounding F0..F7), 1-14:MIDI text event types, 15=REAPER notation event.

void midi_reinit()
midi_reinit()
reaper.midi_reinit()
RPR_midi_reinit()

Reset (close and re-open) all MIDI devices

void MIDI_SelectAll(MediaItem_Take* take, bool select)
MIDI_SelectAll(MediaItem_Take take, bool select)
reaper.MIDI_SelectAll(MediaItem_Take take, boolean select)
RPR_MIDI_SelectAll(MediaItem_Take take, Boolean select)

Select or deselect all MIDI content.

bool MIDI_SetAllEvts(MediaItem_Take* take, const char* buf, int buf_sz)
bool MIDI_SetAllEvts(MediaItem_Take take, "buf")
boolean reaper.MIDI_SetAllEvts(MediaItem_Take take, string buf)
Boolean RPR_MIDI_SetAllEvts(MediaItem_Take take, String buf, Int buf_sz)

Set all MIDI data. MIDI buffer is passed in as a list of { int offset, char flag, int msglen, unsigned char msg[] }.
offset: MIDI ticks from previous event
flag: &1=selected &2=muted
flag high 4 bits for CC shape: &16=linear, &32=slow start/end, &16|32=fast start, &64=fast end, &64|16=bezier
msg: the MIDI message.
A meta-event of type 0xF followed by 'CCBZ ' and 5 more bytes represents bezier curve data for the previous MIDI event: 1 byte for the bezier type (usually 0) and 4 bytes for the bezier tension as a float.
For tick intervals longer than a 32 bit word can represent, zero-length meta events may be placed between valid events.
See MIDI_GetAllEvts.

bool MIDI_SetCC(MediaItem_Take* take, int ccidx, const bool* selectedInOptional, const bool* mutedInOptional, const double* ppqposInOptional, const int* chanmsgInOptional, const int* chanInOptional, const int* msg2InOptional, const int* msg3InOptional, const bool* noSortInOptional)
bool MIDI_SetCC(MediaItem_Take take, int ccidx, optional bool selectedIn, optional bool mutedIn, optional ppqposIn, optional int chanmsgIn, optional int chanIn, optional int msg2In, optional int msg3In, optional bool noSortIn)
boolean reaper.MIDI_SetCC(MediaItem_Take take, integer ccidx, optional boolean selectedIn, optional boolean mutedIn, optional number ppqposIn, optional integer chanmsgIn, optional integer chanIn, optional integer msg2In, optional integer msg3In, optional boolean noSortIn)
Boolean RPR_MIDI_SetCC(MediaItem_Take take, Int ccidx, const bool selectedInOptional, const bool mutedInOptional, const double ppqposInOptional, const int chanmsgInOptional, const int chanInOptional, const int msg2InOptional, const int msg3InOptional, const bool noSortInOptional)

Set MIDI CC event properties. Properties passed as NULL will not be set. set noSort if setting multiple events, then call MIDI_Sort when done.

bool MIDI_SetCCShape(MediaItem_Take* take, int ccidx, int shape, double beztension, const bool* noSortInOptional)
bool MIDI_SetCCShape(MediaItem_Take take, int ccidx, int shape, beztension, optional bool noSortIn)
boolean reaper.MIDI_SetCCShape(MediaItem_Take take, integer ccidx, integer shape, number beztension, optional boolean noSortIn)
Boolean RPR_MIDI_SetCCShape(MediaItem_Take take, Int ccidx, Int shape, Float beztension, const bool noSortInOptional)

Set CC shape and bezier tension. set noSort if setting multiple events, then call MIDI_Sort when done. See MIDI_SetCC, MIDI_GetCCShape

bool MIDI_SetEvt(MediaItem_Take* take, int evtidx, const bool* selectedInOptional, const bool* mutedInOptional, const double* ppqposInOptional, const char* msgOptional, int msgOptional_sz, const bool* noSortInOptional)
bool MIDI_SetEvt(MediaItem_Take take, int evtidx, optional bool selectedIn, optional bool mutedIn, optional ppqposIn, optional "msg", optional bool noSortIn)
boolean reaper.MIDI_SetEvt(MediaItem_Take take, integer evtidx, optional boolean selectedIn, optional boolean mutedIn, optional number ppqposIn, optional string msg, optional boolean noSortIn)
Boolean RPR_MIDI_SetEvt(MediaItem_Take take, Int evtidx, const bool selectedInOptional, const bool mutedInOptional, const double ppqposInOptional, String msgOptional, Int msgOptional_sz, const bool noSortInOptional)

Set MIDI event properties. Properties passed as NULL will not be set. set noSort if setting multiple events, then call MIDI_Sort when done.

bool MIDI_SetItemExtents(MediaItem* item, double startQN, double endQN)
bool MIDI_SetItemExtents(MediaItem item, startQN, endQN)
boolean reaper.MIDI_SetItemExtents(MediaItem item, number startQN, number endQN)
Boolean RPR_MIDI_SetItemExtents(MediaItem item, Float startQN, Float endQN)

Set the start/end positions of a media item that contains a MIDI take.

bool MIDI_SetNote(MediaItem_Take* take, int noteidx, const bool* selectedInOptional, const bool* mutedInOptional, const double* startppqposInOptional, const double* endppqposInOptional, const int* chanInOptional, const int* pitchInOptional, const int* velInOptional, const bool* noSortInOptional)
bool MIDI_SetNote(MediaItem_Take take, int noteidx, optional bool selectedIn, optional bool mutedIn, optional startppqposIn, optional endppqposIn, optional int chanIn, optional int pitchIn, optional int velIn, optional bool noSortIn)
boolean reaper.MIDI_SetNote(MediaItem_Take take, integer noteidx, optional boolean selectedIn, optional boolean mutedIn, optional number startppqposIn, optional number endppqposIn, optional integer chanIn, optional integer pitchIn, optional integer velIn, optional boolean noSortIn)
Boolean RPR_MIDI_SetNote(MediaItem_Take take, Int noteidx, const bool selectedInOptional, const bool mutedInOptional, const double startppqposInOptional, const double endppqposInOptional, const int chanInOptional, const int pitchInOptional, const int velInOptional, const bool noSortInOptional)

Set MIDI note properties. Properties passed as NULL (or negative values) will not be set. Set noSort if setting multiple events, then call MIDI_Sort when done. Setting multiple note start positions at once is done more safely by deleting and re-inserting the notes.

bool MIDI_SetTextSysexEvt(MediaItem_Take* take, int textsyxevtidx, const bool* selectedInOptional, const bool* mutedInOptional, const double* ppqposInOptional, const int* typeInOptional, const char* msgOptional, int msgOptional_sz, const bool* noSortInOptional)
bool MIDI_SetTextSysexEvt(MediaItem_Take take, int textsyxevtidx, optional bool selectedIn, optional bool mutedIn, optional ppqposIn, optional int typeIn, optional "msg", optional bool noSortIn)
boolean reaper.MIDI_SetTextSysexEvt(MediaItem_Take take, integer textsyxevtidx, optional boolean selectedIn, optional boolean mutedIn, optional number ppqposIn, optional integer typeIn, optional string msg, optional boolean noSortIn)
Boolean RPR_MIDI_SetTextSysexEvt(MediaItem_Take take, Int textsyxevtidx, const bool selectedInOptional, const bool mutedInOptional, const double ppqposInOptional, const int typeInOptional, String msgOptional, Int msgOptional_sz, const bool noSortInOptional)

Set MIDI text or sysex event properties. Properties passed as NULL will not be set. Allowable types are -1:sysex (msg should not include bounding F0..F7), 1-14:MIDI text event types, 15=REAPER notation event. set noSort if setting multiple events, then call MIDI_Sort when done.

void MIDI_Sort(MediaItem_Take* take)
MIDI_Sort(MediaItem_Take take)
reaper.MIDI_Sort(MediaItem_Take take)
RPR_MIDI_Sort(MediaItem_Take take)

Sort MIDI events after multiple calls to MIDI_SetNote, MIDI_SetCC, etc.

MediaItem_Take* MIDIEditor_EnumTakes(HWND midieditor, int takeindex, bool editable_only)
MediaItem_Take MIDIEditor_EnumTakes(HWND midieditor, int takeindex, bool editable_only)
MediaItem_Take reaper.MIDIEditor_EnumTakes(HWND midieditor, integer takeindex, boolean editable_only)
MediaItem_Take RPR_MIDIEditor_EnumTakes(HWND midieditor, Int takeindex, Boolean editable_only)

list the takes that are currently being edited in this MIDI editor, starting with the active take. See MIDIEditor_GetTake

HWND MIDIEditor_GetActive()
HWND MIDIEditor_GetActive()
HWND reaper.MIDIEditor_GetActive()
HWND RPR_MIDIEditor_GetActive()

get a pointer to the focused MIDI editor window
see MIDIEditor_GetMode, MIDIEditor_OnCommand

int MIDIEditor_GetMode(HWND midieditor)
int MIDIEditor_GetMode(HWND midieditor)
integer reaper.MIDIEditor_GetMode(HWND midieditor)
Int RPR_MIDIEditor_GetMode(HWND midieditor)

get the mode of a MIDI editor (0=piano roll, 1=event list, -1=invalid editor)
see MIDIEditor_GetActive, MIDIEditor_OnCommand

int MIDIEditor_GetSetting_int(HWND midieditor, const char* setting_desc)
int MIDIEditor_GetSetting_int(HWND midieditor, "setting_desc")
integer reaper.MIDIEditor_GetSetting_int(HWND midieditor, string setting_desc)
Int RPR_MIDIEditor_GetSetting_int(HWND midieditor, String setting_desc)

Get settings from a MIDI editor. setting_desc can be:
snap_enabled: returns 0 or 1
active_note_row: returns 0-127
last_clicked_cc_lane: returns 0-127=CC, 0x100|(0-31)=14-bit CC, 0x200=velocity, 0x201=pitch, 0x202=program, 0x203=channel pressure, 0x204=bank/program select, 0x205=text, 0x206=sysex, 0x207=off velocity, 0x208=notation events, 0x210=media item lane
default_note_vel: returns 0-127
default_note_chan: returns 0-15
default_note_len: returns default length in MIDI ticks
scale_enabled: returns 0-1
scale_root: returns 0-12 (0=C)
list_cnt: if viewing list view, returns event count
if setting_desc is unsupported, the function returns -1.
See MIDIEditor_SetSetting_int, MIDIEditor_GetActive, MIDIEditor_GetSetting_str

bool MIDIEditor_GetSetting_str(HWND midieditor, const char* setting_desc, char* bufOut, int bufOut_sz)
bool MIDIEditor_GetSetting_str(HWND midieditor, "setting_desc", #buf)
boolean retval, string buf = reaper.MIDIEditor_GetSetting_str(HWND midieditor, string setting_desc)
(Boolean retval, HWND midieditor, String setting_desc, String bufOut, Int bufOut_sz) = RPR_MIDIEditor_GetSetting_str(midieditor, setting_desc, bufOut, bufOut_sz)

Get settings from a MIDI editor. setting_desc can be:
last_clicked_cc_lane: returns text description ("velocity", "pitch", etc)
scale: returns the scale record, for example "102034050607" for a major scale
list_X: if viewing list view, returns string describing event at row X (0-based). String will have a list of key=value pairs, e.g. 'pos=4.0 len=4.0 offvel=127 msg=90317F'. pos/len times are in QN, len/offvel may not be present if event is not a note. other keys which may be present include pos_pq/len_pq, sel, mute, ccval14, ccshape, ccbeztension.
if setting_desc is unsupported, the function returns false.
See MIDIEditor_GetActive, MIDIEditor_GetSetting_int

MediaItem_Take* MIDIEditor_GetTake(HWND midieditor)
MediaItem_Take MIDIEditor_GetTake(HWND midieditor)
MediaItem_Take reaper.MIDIEditor_GetTake(HWND midieditor)
MediaItem_Take RPR_MIDIEditor_GetTake(HWND midieditor)

get the take that is currently being edited in this MIDI editor. see MIDIEditor_EnumTakes

bool MIDIEditor_LastFocused_OnCommand(int command_id, bool islistviewcommand)
bool MIDIEditor_LastFocused_OnCommand(int command_id, bool islistviewcommand)
boolean reaper.MIDIEditor_LastFocused_OnCommand(integer command_id, boolean islistviewcommand)
Boolean RPR_MIDIEditor_LastFocused_OnCommand(Int command_id, Boolean islistviewcommand)

Send an action command to the last focused MIDI editor. Returns false if there is no MIDI editor open, or if the view mode (piano roll or event list) does not match the input.
see MIDIEditor_OnCommand

bool MIDIEditor_OnCommand(HWND midieditor, int command_id)
bool MIDIEditor_OnCommand(HWND midieditor, int command_id)
boolean reaper.MIDIEditor_OnCommand(HWND midieditor, integer command_id)
Boolean RPR_MIDIEditor_OnCommand(HWND midieditor, Int command_id)

Send an action command to a MIDI editor. Returns false if the supplied MIDI editor pointer is not valid (not an open MIDI editor).
see MIDIEditor_GetActive, MIDIEditor_LastFocused_OnCommand

bool MIDIEditor_SetSetting_int(HWND midieditor, const char* setting_desc, int setting)
bool MIDIEditor_SetSetting_int(HWND midieditor, "setting_desc", int setting)
boolean reaper.MIDIEditor_SetSetting_int(HWND midieditor, string setting_desc, integer setting)
Boolean RPR_MIDIEditor_SetSetting_int(HWND midieditor, String setting_desc, Int setting)

Set settings for a MIDI editor. setting_desc can be:
active_note_row: 0-127
See MIDIEditor_GetSetting_int

void MIDIEditorFlagsForTrack(MediaTrack* track, int* pitchwheelrangeInOut, int* flagsInOut, bool is_set)
MIDIEditorFlagsForTrack(MediaTrack track, int &pitchwheelrange, int &flags, bool is_set)
integer pitchwheelrange, integer flags = reaper.MIDIEditorFlagsForTrack(MediaTrack track, integer pitchwheelrange, integer flags, boolean is_set)
(MediaTrack track, Int pitchwheelrangeInOut, Int flagsInOut, Boolean is_set) = RPR_MIDIEditorFlagsForTrack(track, pitchwheelrangeInOut, flagsInOut, is_set)

Get or set MIDI editor settings for this track. pitchwheelrange: semitones up or down. flags &1: snap pitch lane edits to semitones if pitchwheel range is defined.

void mkpanstr(char* strNeed64, double pan)
mkpanstr(#strNeed64, pan)
string strNeed64 = reaper.mkpanstr(string strNeed64, number pan)
(String strNeed64, Float pan) = RPR_mkpanstr(strNeed64, pan)
void mkvolpanstr(char* strNeed64, double vol, double pan)
mkvolpanstr(#strNeed64, vol, pan)
string strNeed64 = reaper.mkvolpanstr(string strNeed64, number vol, number pan)
(String strNeed64, Float vol, Float pan) = RPR_mkvolpanstr(strNeed64, vol, pan)
void mkvolstr(char* strNeed64, double vol)
mkvolstr(#strNeed64, vol)
string strNeed64 = reaper.mkvolstr(string strNeed64, number vol)
(String strNeed64, Float vol) = RPR_mkvolstr(strNeed64, vol)
void MoveEditCursor(double adjamt, bool dosel)
MoveEditCursor(adjamt, bool dosel)
reaper.MoveEditCursor(number adjamt, boolean dosel)
RPR_MoveEditCursor(Float adjamt, Boolean dosel)
bool MoveMediaItemToTrack(MediaItem* item, MediaTrack* desttr)
bool MoveMediaItemToTrack(MediaItem item, MediaTrack desttr)
boolean reaper.MoveMediaItemToTrack(MediaItem item, MediaTrack desttr)
Boolean RPR_MoveMediaItemToTrack(MediaItem item, MediaTrack desttr)

returns TRUE if move succeeded

void MuteAllTracks(bool mute)
MuteAllTracks(bool mute)
reaper.MuteAllTracks(boolean mute)
RPR_MuteAllTracks(Boolean mute)
void my_getViewport(RECT* r, const RECT* sr, bool wantWorkArea)
my_getViewport(int &r.left, int &r.top, int &r.right, int &r.bot, int sr.left, int sr.top, int sr.right, int sr.bot, bool wantWorkArea)
reaper.my_getViewport(integerr.left, integerr.top, integerr.right, integerr.bot, integer sr.left, integer sr.top, integer sr.right, integer sr.bot, boolean wantWorkArea)
RPR_my_getViewport(RECT r, const RECT sr, Boolean wantWorkArea)
int NamedCommandLookup(const char* command_name)
int NamedCommandLookup("command_name")
integer reaper.NamedCommandLookup(string command_name)
Int RPR_NamedCommandLookup(String command_name)

Get the command ID number for named command that was registered by an extension such as "_SWS_ABOUT" or "_113088d11ae641c193a2b7ede3041ad5" for a ReaScript or a custom action.

void OnPauseButton()
OnPauseButton()
reaper.OnPauseButton()
RPR_OnPauseButton()

direct way to simulate pause button hit

void OnPauseButtonEx(ReaProject* proj)
OnPauseButtonEx(ReaProject proj)
reaper.OnPauseButtonEx(ReaProject proj)
RPR_OnPauseButtonEx(ReaProject proj)

direct way to simulate pause button hit

void OnPlayButton()
OnPlayButton()
reaper.OnPlayButton()
RPR_OnPlayButton()

direct way to simulate play button hit

void OnPlayButtonEx(ReaProject* proj)
OnPlayButtonEx(ReaProject proj)
reaper.OnPlayButtonEx(ReaProject proj)
RPR_OnPlayButtonEx(ReaProject proj)

direct way to simulate play button hit

void OnStopButton()
OnStopButton()
reaper.OnStopButton()
RPR_OnStopButton()

direct way to simulate stop button hit

void OnStopButtonEx(ReaProject* proj)
OnStopButtonEx(ReaProject proj)
reaper.OnStopButtonEx(ReaProject proj)
RPR_OnStopButtonEx(ReaProject proj)

direct way to simulate stop button hit

bool OpenColorThemeFile(const char* fn)
bool OpenColorThemeFile("fn")
boolean reaper.OpenColorThemeFile(string fn)
Boolean RPR_OpenColorThemeFile(String fn)
HWND OpenMediaExplorer(const char* mediafn, bool play)
HWND OpenMediaExplorer("mediafn", bool play)
HWND reaper.OpenMediaExplorer(string mediafn, boolean play)
HWND RPR_OpenMediaExplorer(String mediafn, Boolean play)

Opens mediafn in the Media Explorer, play=true will play the file immediately (or toggle playback if mediafn was already open), =false will just select it.

void OscLocalMessageToHost(const char* message, const double* valueInOptional)
OscLocalMessageToHost("message", optional valueIn)
reaper.OscLocalMessageToHost(string message, optional number valueIn)
RPR_OscLocalMessageToHost(String message, const double valueInOptional)

Send an OSC message directly to REAPER. The value argument may be NULL. The message will be matched against the default OSC patterns.

double parse_timestr(const char* buf)
double parse_timestr("buf")
number reaper.parse_timestr(string buf)
Float RPR_parse_timestr(String buf)

Parse hh:mm:ss.sss time string, return time in seconds (or 0.0 on error). See parse_timestr_pos, parse_timestr_len.

double parse_timestr_len(const char* buf, double offset, int modeoverride)
double parse_timestr_len("buf", offset, int modeoverride)
number reaper.parse_timestr_len(string buf, number offset, integer modeoverride)
Float RPR_parse_timestr_len(String buf, Float offset, Int modeoverride)

time formatting mode overrides: -1=proj default.
0=time
1=measures.beats + time
2=measures.beats
3=seconds
4=samples
5=h:m:s:f

double parse_timestr_pos(const char* buf, int modeoverride)
double parse_timestr_pos("buf", int modeoverride)
number reaper.parse_timestr_pos(string buf, integer modeoverride)
Float RPR_parse_timestr_pos(String buf, Int modeoverride)

Parse time string, time formatting mode overrides: -1=proj default.
0=time
1=measures.beats + time
2=measures.beats
3=seconds
4=samples
5=h:m:s:f

double parsepanstr(const char* str)
double parsepanstr("str")
number reaper.parsepanstr(string str)
Float RPR_parsepanstr(String str)
unsigned int PCM_Sink_Enum(int idx, const char** descstrOut)
uint PCM_Sink_Enum(int idx, #descstr)
integer retval, string descstr = reaper.PCM_Sink_Enum(integer idx)
Unknown RPR_PCM_Sink_Enum(Int idx, String descstrOut)
const char* PCM_Sink_GetExtension(const char* data, int data_sz)
bool PCM_Sink_GetExtension(#retval, "data")
string reaper.PCM_Sink_GetExtension(string data)
String RPR_PCM_Sink_GetExtension(String data, Int data_sz)
HWND PCM_Sink_ShowConfig(const char* cfg, int cfg_sz, HWND hwndParent)
HWND PCM_Sink_ShowConfig("cfg", HWND hwndParent)
HWND reaper.PCM_Sink_ShowConfig(string cfg, HWND hwndParent)
HWND RPR_PCM_Sink_ShowConfig(String cfg, Int cfg_sz, HWND hwndParent)
int PCM_Source_BuildPeaks(PCM_source* src, int mode)
int PCM_Source_BuildPeaks(PCM_source src, int mode)
integer reaper.PCM_Source_BuildPeaks(PCM_source src, integer mode)
Int RPR_PCM_Source_BuildPeaks(PCM_source src, Int mode)

Calls and returns PCM_source::PeaksBuild_Begin() if mode=0, PeaksBuild_Run() if mode=1, and PeaksBuild_Finish() if mode=2. Normal use is to call PCM_Source_BuildPeaks(src,0), and if that returns nonzero, call PCM_Source_BuildPeaks(src,1) periodically until it returns zero (it returns the percentage of the file remaining), then call PCM_Source_BuildPeaks(src,2) to finalize. If PCM_Source_BuildPeaks(src,0) returns zero, then no further action is necessary.

PCM_source* PCM_Source_CreateFromFile(const char* filename)
PCM_source PCM_Source_CreateFromFile("filename")
PCM_source reaper.PCM_Source_CreateFromFile(string filename)
PCM_source RPR_PCM_Source_CreateFromFile(String filename)

See PCM_Source_CreateFromFileEx.

PCM_source* PCM_Source_CreateFromFileEx(const char* filename, bool forcenoMidiImp)
PCM_source PCM_Source_CreateFromFileEx("filename", bool forcenoMidiImp)
PCM_source reaper.PCM_Source_CreateFromFileEx(string filename, boolean forcenoMidiImp)
PCM_source RPR_PCM_Source_CreateFromFileEx(String filename, Boolean forcenoMidiImp)

Create a PCM_source from filename, and override pref of MIDI files being imported as in-project MIDI events.

PCM_source* PCM_Source_CreateFromType(const char* sourcetype)
PCM_source PCM_Source_CreateFromType("sourcetype")
PCM_source reaper.PCM_Source_CreateFromType(string sourcetype)
PCM_source RPR_PCM_Source_CreateFromType(String sourcetype)

Create a PCM_source from a "type" (use this if you're going to load its state via LoadState/ProjectStateContext).
Valid types include "WAVE", "MIDI", or whatever plug-ins define as well.

void PCM_Source_Destroy(PCM_source* src)
PCM_Source_Destroy(PCM_source src)
reaper.PCM_Source_Destroy(PCM_source src)
RPR_PCM_Source_Destroy(PCM_source src)

Deletes a PCM_source -- be sure that you remove any project reference before deleting a source

int PCM_Source_GetPeaks(PCM_source* src, double peakrate, double starttime, int numchannels, int numsamplesperchannel, int want_extra_type, double* buf)
int PCM_Source_GetPeaks(PCM_source src, peakrate, starttime, int numchannels, int numsamplesperchannel, int want_extra_type, buffer_ptr buf)
integer reaper.PCM_Source_GetPeaks(PCM_source src, number peakrate, number starttime, integer numchannels, integer numsamplesperchannel, integer want_extra_type, reaper.array buf)
(Int retval, PCM_source src, Float peakrate, Float starttime, Int numchannels, Int numsamplesperchannel, Int want_extra_type, Float buf) = RPR_PCM_Source_GetPeaks(src, peakrate, starttime, numchannels, numsamplesperchannel, want_extra_type, buf)

Gets block of peak samples to buf. Note that the peak samples are interleaved, but in two or three blocks (maximums, then minimums, then extra). Return value has 20 bits of returned sample count, then 4 bits of output_mode (0xf00000), then a bit to signify whether extra_type was available (0x1000000). extra_type can be 115 ('s') for spectral information, which will return peak samples as integers with the low 15 bits frequency, next 14 bits tonality.

bool PCM_Source_GetSectionInfo(PCM_source* src, double* offsOut, double* lenOut, bool* revOut)
bool PCM_Source_GetSectionInfo(PCM_source src, &offs, &len, bool &rev)
boolean retval, number offs, number len, boolean rev = reaper.PCM_Source_GetSectionInfo(PCM_source src)
(Boolean retval, PCM_source src, Float offsOut, Float lenOut, Boolean revOut) = RPR_PCM_Source_GetSectionInfo(src, offsOut, lenOut, revOut)

If a section/reverse block, retrieves offset/len/reverse. return true if success

void PluginWantsAlwaysRunFx(int amt)
PluginWantsAlwaysRunFx(int amt)
reaper.PluginWantsAlwaysRunFx(integer amt)
RPR_PluginWantsAlwaysRunFx(Int amt)
void PreventUIRefresh(int prevent_count)
PreventUIRefresh(int prevent_count)
reaper.PreventUIRefresh(integer prevent_count)
RPR_PreventUIRefresh(Int prevent_count)

adds prevent_count to the UI refresh prevention state; always add then remove the same amount, or major disfunction will occur

int PromptForAction(int session_mode, int init_id, int section_id)
int PromptForAction(int session_mode, int init_id, int section_id)
integer reaper.PromptForAction(integer session_mode, integer init_id, integer section_id)
Int RPR_PromptForAction(Int session_mode, Int init_id, Int section_id)

Uses the action list to choose an action. Call with session_mode=1 to create a session (init_id will be the initial action to select, or 0), then poll with session_mode=0, checking return value for user-selected action (will return 0 if no action selected yet, or -1 if the action window is no longer available). When finished, call with session_mode=-1.

void ReaScriptError(const char* errmsg)
ReaScriptError("errmsg")
reaper.ReaScriptError(string errmsg)
RPR_ReaScriptError(String errmsg)

Causes REAPER to display the error message after the current ReaScript finishes. If called within a Lua context and errmsg has a ! prefix, script execution will be terminated.

int RecursiveCreateDirectory(const char* path, size_t ignored)
int RecursiveCreateDirectory("path", size_t ignored)
integer reaper.RecursiveCreateDirectory(string path, integer ignored)
Int RPR_RecursiveCreateDirectory(String path, Unknown ignored)

returns positive value on success, 0 on failure.

int reduce_open_files(int flags)
int reduce_open_files(int flags)
integer reaper.reduce_open_files(integer flags)
Int RPR_reduce_open_files(Int flags)

garbage-collects extra open files and closes them. if flags has 1 set, this is done incrementally (call this from a regular timer, if desired). if flags has 2 set, files are aggressively closed (they may need to be re-opened very soon). returns number of files closed by this call.

void RefreshToolbar(int command_id)
RefreshToolbar(int command_id)
reaper.RefreshToolbar(integer command_id)
RPR_RefreshToolbar(Int command_id)

See RefreshToolbar2.

void RefreshToolbar2(int section_id, int command_id)
RefreshToolbar2(int section_id, int command_id)
reaper.RefreshToolbar2(integer section_id, integer command_id)
RPR_RefreshToolbar2(Int section_id, Int command_id)

Refresh the toolbar button states of a toggle action.

void relative_fn(const char* in, char* out, int out_sz)
relative_fn("in", #out)
string out = reaper.relative_fn(string in, string out)
(String in, String out, Int out_sz) = RPR_relative_fn(in, out, out_sz)

Makes a filename "in" relative to the current project, if any.

bool RemoveTrackSend(MediaTrack* tr, int category, int sendidx)
bool RemoveTrackSend(MediaTrack tr, int category, int sendidx)
boolean reaper.RemoveTrackSend(MediaTrack tr, integer category, integer sendidx)
Boolean RPR_RemoveTrackSend(MediaTrack tr, Int category, Int sendidx)

Remove a send/receive/hardware output, return true on success. category is <0 for receives, 0=sends, >0 for hardware outputs. See CreateTrackSend, GetSetTrackSendInfo, GetTrackSendInfo_Value, SetTrackSendInfo_Value, GetTrackNumSends.

bool RenderFileSection(const char* source_filename, const char* target_filename, double start_percent, double end_percent, double playrate)
bool RenderFileSection("source_filename", "target_filename", start_percent, end_percent, playrate)
boolean reaper.RenderFileSection(string source_filename, string target_filename, number start_percent, number end_percent, number playrate)
Boolean RPR_RenderFileSection(String source_filename, String target_filename, Float start_percent, Float end_percent, Float playrate)

Not available while playing back.

bool ReorderSelectedTracks(int beforeTrackIdx, int makePrevFolder)
bool ReorderSelectedTracks(int beforeTrackIdx, int makePrevFolder)
boolean reaper.ReorderSelectedTracks(integer beforeTrackIdx, integer makePrevFolder)
Boolean RPR_ReorderSelectedTracks(Int beforeTrackIdx, Int makePrevFolder)

Moves all selected tracks to immediately above track specified by index beforeTrackIdx, returns false if no tracks were selected. makePrevFolder=0 for normal, 1 = as child of track preceding track specified by beforeTrackIdx, 2 = if track preceding track specified by beforeTrackIdx is last track in folder, extend folder

const char* Resample_EnumModes(int mode)
bool Resample_EnumModes(#retval, int mode)
string reaper.Resample_EnumModes(integer mode)
String RPR_Resample_EnumModes(Int mode)
void resolve_fn(const char* in, char* out, int out_sz)
resolve_fn("in", #out)
string out = reaper.resolve_fn(string in, string out)
(String in, String out, Int out_sz) = RPR_resolve_fn(in, out, out_sz)

See resolve_fn2.

void resolve_fn2(const char* in, char* out, int out_sz, const char* checkSubDirOptional)
resolve_fn2("in", #out, optional "checkSubDir")
string out = reaper.resolve_fn2(string in, string out, optional string checkSubDir)
(String in, String out, Int out_sz, String checkSubDirOptional) = RPR_resolve_fn2(in, out, out_sz, checkSubDirOptional)

Resolves a filename "in" by using project settings etc. If no file found, out will be a copy of in.

const char* ReverseNamedCommandLookup(int command_id)
bool ReverseNamedCommandLookup(#retval, int command_id)
string reaper.ReverseNamedCommandLookup(integer command_id)
String RPR_ReverseNamedCommandLookup(Int command_id)

Get the named command for the given command ID. The returned string will not start with '_' (e.g. it will return "SWS_ABOUT"), it will be NULL if command_id is a native action.

double ScaleFromEnvelopeMode(int scaling_mode, double val)
double ScaleFromEnvelopeMode(int scaling_mode, val)
number reaper.ScaleFromEnvelopeMode(integer scaling_mode, number val)
Float RPR_ScaleFromEnvelopeMode(Int scaling_mode, Float val)

See GetEnvelopeScalingMode.

double ScaleToEnvelopeMode(int scaling_mode, double val)
double ScaleToEnvelopeMode(int scaling_mode, val)
number reaper.ScaleToEnvelopeMode(integer scaling_mode, number val)
Float RPR_ScaleToEnvelopeMode(Int scaling_mode, Float val)

See GetEnvelopeScalingMode.

KbdSectionInfo* SectionFromUniqueID(int uniqueID)
KbdSectionInfo SectionFromUniqueID(int uniqueID)
KbdSectionInfo reaper.SectionFromUniqueID(integer uniqueID)
KbdSectionInfo RPR_SectionFromUniqueID(Int uniqueID)
void SelectAllMediaItems(ReaProject* proj, bool selected)
SelectAllMediaItems(ReaProject proj, bool selected)
reaper.SelectAllMediaItems(ReaProject proj, boolean selected)
RPR_SelectAllMediaItems(ReaProject proj, Boolean selected)
void SelectProjectInstance(ReaProject* proj)
SelectProjectInstance(ReaProject proj)
reaper.SelectProjectInstance(ReaProject proj)
RPR_SelectProjectInstance(ReaProject proj)
void SendMIDIMessageToHardware(int output, const char* msg, int msg_sz)
SendMIDIMessageToHardware(int output, "msg")
reaper.SendMIDIMessageToHardware(integer output, string msg)
RPR_SendMIDIMessageToHardware(Int output, String msg, Int msg_sz)

Sends a MIDI message to output device specified by output. Message is sent in immediate mode.

void SetActiveTake(MediaItem_Take* take)
SetActiveTake(MediaItem_Take take)
reaper.SetActiveTake(MediaItem_Take take)
RPR_SetActiveTake(MediaItem_Take take)

set this take active in this media item

void SetAutomationMode(int mode, bool onlySel)
SetAutomationMode(int mode, bool onlySel)
reaper.SetAutomationMode(integer mode, boolean onlySel)
RPR_SetAutomationMode(Int mode, Boolean onlySel)

sets all or selected tracks to mode.

void SetCurrentBPM(ReaProject* __proj, double bpm, bool wantUndo)
SetCurrentBPM(ReaProject __proj, bpm, bool wantUndo)
reaper.SetCurrentBPM(ReaProject __proj, number bpm, boolean wantUndo)
RPR_SetCurrentBPM(ReaProject __proj, Float bpm, Boolean wantUndo)

set current BPM in project, set wantUndo=true to add undo point

void SetCursorContext(int mode, TrackEnvelope* envInOptional)
SetCursorContext(int mode, TrackEnvelope envIn)
reaper.SetCursorContext(integer mode, TrackEnvelope envIn)
RPR_SetCursorContext(Int mode, TrackEnvelope envInOptional)

You must use this to change the focus programmatically. mode=0 to focus track panels, 1 to focus the arrange window, 2 to focus the arrange window and select env (or env==NULL to clear the current track/take envelope selection)

void SetEditCurPos(double time, bool moveview, bool seekplay)
SetEditCurPos(time, bool moveview, bool seekplay)
reaper.SetEditCurPos(number time, boolean moveview, boolean seekplay)
RPR_SetEditCurPos(Float time, Boolean moveview, Boolean seekplay)
void SetEditCurPos2(ReaProject* proj, double time, bool moveview, bool seekplay)
SetEditCurPos2(ReaProject proj, time, bool moveview, bool seekplay)
reaper.SetEditCurPos2(ReaProject proj, number time, boolean moveview, boolean seekplay)
RPR_SetEditCurPos2(ReaProject proj, Float time, Boolean moveview, Boolean seekplay)
bool SetEnvelopePoint(TrackEnvelope* envelope, int ptidx, double* timeInOptional, double* valueInOptional, int* shapeInOptional, double* tensionInOptional, bool* selectedInOptional, bool* noSortInOptional)
bool SetEnvelopePoint(TrackEnvelope envelope, int ptidx, optional timeIn, optional valueIn, optional int shapeIn, optional tensionIn, optional bool selectedIn, optional bool noSortIn)
boolean reaper.SetEnvelopePoint(TrackEnvelope envelope, integer ptidx, optional number timeIn, optional number valueIn, optional integer shapeIn, optional number tensionIn, optional boolean selectedIn, optional boolean noSortIn)
(Boolean retval, TrackEnvelope envelope, Int ptidx, Float timeInOptional, Float valueInOptional, Int shapeInOptional, Float tensionInOptional, Boolean selectedInOptional, Boolean noSortInOptional) = RPR_SetEnvelopePoint(envelope, ptidx, timeInOptional, valueInOptional, shapeInOptional, tensionInOptional, selectedInOptional, noSortInOptional)

Set attributes of an envelope point. Values that are not supplied will be ignored. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done. See SetEnvelopePointEx.

bool SetEnvelopePointEx(TrackEnvelope* envelope, int autoitem_idx, int ptidx, double* timeInOptional, double* valueInOptional, int* shapeInOptional, double* tensionInOptional, bool* selectedInOptional, bool* noSortInOptional)
bool SetEnvelopePointEx(TrackEnvelope envelope, int autoitem_idx, int ptidx, optional timeIn, optional valueIn, optional int shapeIn, optional tensionIn, optional bool selectedIn, optional bool noSortIn)
boolean reaper.SetEnvelopePointEx(TrackEnvelope envelope, integer autoitem_idx, integer ptidx, optional number timeIn, optional number valueIn, optional integer shapeIn, optional number tensionIn, optional boolean selectedIn, optional boolean noSortIn)
(Boolean retval, TrackEnvelope envelope, Int autoitem_idx, Int ptidx, Float timeInOptional, Float valueInOptional, Int shapeInOptional, Float tensionInOptional, Boolean selectedInOptional, Boolean noSortInOptional) = RPR_SetEnvelopePointEx(envelope, autoitem_idx, ptidx, timeInOptional, valueInOptional, shapeInOptional, tensionInOptional, selectedInOptional, noSortInOptional)

Set attributes of an envelope point. Values that are not supplied will be ignored. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See CountEnvelopePointsEx, GetEnvelopePointEx, InsertEnvelopePointEx, DeleteEnvelopePointEx.

bool SetEnvelopeStateChunk(TrackEnvelope* env, const char* str, bool isundoOptional)
bool SetEnvelopeStateChunk(TrackEnvelope env, "str", bool isundo)
boolean reaper.SetEnvelopeStateChunk(TrackEnvelope env, string str, boolean isundo)
Boolean RPR_SetEnvelopeStateChunk(TrackEnvelope env, String str, Boolean isundoOptional)

Sets the RPPXML state of an envelope, returns true if successful. Undo flag is a performance/caching hint.

void SetExtState(const char* section, const char* key, const char* value, bool persist)
SetExtState("section", "key", "value", bool persist)
reaper.SetExtState(string section, string key, string value, boolean persist)
RPR_SetExtState(String section, String key, String value, Boolean persist)

Set the extended state value for a specific section and key. persist=true means the value should be stored and reloaded the next time REAPER is opened. See GetExtState, DeleteExtState, HasExtState.

void SetGlobalAutomationOverride(int mode)
SetGlobalAutomationOverride(int mode)
reaper.SetGlobalAutomationOverride(integer mode)
RPR_SetGlobalAutomationOverride(Int mode)

mode: see GetGlobalAutomationOverride

bool SetItemStateChunk(MediaItem* item, const char* str, bool isundoOptional)
bool SetItemStateChunk(MediaItem item, "str", bool isundo)
boolean reaper.SetItemStateChunk(MediaItem item, string str, boolean isundo)
Boolean RPR_SetItemStateChunk(MediaItem item, String str, Boolean isundoOptional)

Sets the RPPXML state of an item, returns true if successful. Undo flag is a performance/caching hint.

int SetMasterTrackVisibility(int flag)
int SetMasterTrackVisibility(int flag)
integer reaper.SetMasterTrackVisibility(integer flag)
Int RPR_SetMasterTrackVisibility(Int flag)

set &1 to show the master track in the TCP, &2 to HIDE in the mixer. Returns the previous visibility state. See GetMasterTrackVisibility.

bool SetMediaItemInfo_Value(MediaItem* item, const char* parmname, double newvalue)
bool SetMediaItemInfo_Value(MediaItem item, "parmname", newvalue)
boolean reaper.SetMediaItemInfo_Value(MediaItem item, string parmname, number newvalue)
Boolean RPR_SetMediaItemInfo_Value(MediaItem item, String parmname, Float newvalue)

Set media item numerical-value attributes.
B_MUTE : bool * : muted (item solo overrides). setting this value will clear C_MUTE_SOLO.
B_MUTE_ACTUAL : bool * : muted (ignores solo). setting this value will not affect C_MUTE_SOLO.
C_LANEPLAYS : char * : in fixed lane tracks, 0=this item lane does not play, 1=this item lane plays exclusively, 2=this item lane plays and other lanes also play, -1=this item is on a non-visible, non-playing lane on a non-fixed-lane track (read-only)
C_MUTE_SOLO : char * : solo override (-1=soloed, 0=no override, 1=unsoloed). note that this API does not automatically unsolo other items when soloing (nor clear the unsolos when clearing the last soloed item), it must be done by the caller via action or via this API.
B_LOOPSRC : bool * : loop source
B_ALLTAKESPLAY : bool * : all takes play
B_UISEL : bool * : selected in arrange view
C_BEATATTACHMODE : char * : item timebase, -1=track or project default, 1=beats (position, length, rate), 2=beats (position only). for auto-stretch timebase: C_BEATATTACHMODE=1, C_AUTOSTRETCH=1
C_AUTOSTRETCH: : char * : auto-stretch at project tempo changes, 1=enabled, requires C_BEATATTACHMODE=1
C_LOCK : char * : locked, &1=locked
D_VOL : double * : item volume, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc
D_POSITION : double * : item position in seconds
D_LENGTH : double * : item length in seconds
D_SNAPOFFSET : double * : item snap offset in seconds
D_FADEINLEN : double * : item manual fadein length in seconds
D_FADEOUTLEN : double * : item manual fadeout length in seconds
D_FADEINDIR : double * : item fadein curvature, -1..1
D_FADEOUTDIR : double * : item fadeout curvature, -1..1
D_FADEINLEN_AUTO : double * : item auto-fadein length in seconds, -1=no auto-fadein
D_FADEOUTLEN_AUTO : double * : item auto-fadeout length in seconds, -1=no auto-fadeout
C_FADEINSHAPE : int * : fadein shape, 0..6, 0=linear
C_FADEOUTSHAPE : int * : fadeout shape, 0..6, 0=linear
I_GROUPID : int * : group ID, 0=no group
I_LASTY : int * : Y-position (relative to top of track) in pixels (read-only)
I_LASTH : int * : height in pixels (read-only)
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
I_CURTAKE : int * : active take number
IP_ITEMNUMBER : int : item number on this track (read-only, returns the item number directly)
F_FREEMODE_Y : float * : free item positioning or fixed lane Y-position. 0=top of track, 1.0=bottom of track
F_FREEMODE_H : float * : free item positioning or fixed lane height. 0.5=half the track height, 1.0=full track height
I_FIXEDLANE : int * : fixed lane of item (fine to call with setNewValue, but returned value is read-only)
B_FIXEDLANE_HIDDEN : bool * : true if displaying only one fixed lane and this item is in a different lane (read-only)

bool SetMediaItemLength(MediaItem* item, double length, bool refreshUI)
bool SetMediaItemLength(MediaItem item, length, bool refreshUI)
boolean reaper.SetMediaItemLength(MediaItem item, number length, boolean refreshUI)
Boolean RPR_SetMediaItemLength(MediaItem item, Float length, Boolean refreshUI)

Redraws the screen only if refreshUI == true.
See UpdateArrange().

bool SetMediaItemPosition(MediaItem* item, double position, bool refreshUI)
bool SetMediaItemPosition(MediaItem item, position, bool refreshUI)
boolean reaper.SetMediaItemPosition(MediaItem item, number position, boolean refreshUI)
Boolean RPR_SetMediaItemPosition(MediaItem item, Float position, Boolean refreshUI)

Redraws the screen only if refreshUI == true.
See UpdateArrange().

void SetMediaItemSelected(MediaItem* item, bool selected)
SetMediaItemSelected(MediaItem item, bool selected)
reaper.SetMediaItemSelected(MediaItem item, boolean selected)
RPR_SetMediaItemSelected(MediaItem item, Boolean selected)
bool SetMediaItemTake_Source(MediaItem_Take* take, PCM_source* source)
bool SetMediaItemTake_Source(MediaItem_Take take, PCM_source source)
boolean reaper.SetMediaItemTake_Source(MediaItem_Take take, PCM_source source)
Boolean RPR_SetMediaItemTake_Source(MediaItem_Take take, PCM_source source)

Set media source of media item take. The old source will not be destroyed, it is the caller's responsibility to retrieve it and destroy it after. If source already exists in any project, it will be duplicated before being set. C/C++ code should not use this and instead use GetSetMediaItemTakeInfo() with P_SOURCE to manage ownership directly.

bool SetMediaItemTakeInfo_Value(MediaItem_Take* take, const char* parmname, double newvalue)
bool SetMediaItemTakeInfo_Value(MediaItem_Take take, "parmname", newvalue)
boolean reaper.SetMediaItemTakeInfo_Value(MediaItem_Take take, string parmname, number newvalue)
Boolean RPR_SetMediaItemTakeInfo_Value(MediaItem_Take take, String parmname, Float newvalue)

Set media item take numerical-value attributes.
D_STARTOFFS : double * : start offset in source media, in seconds
D_VOL : double * : take volume, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc, negative if take polarity is flipped
D_PAN : double * : take pan, -1..1
D_PANLAW : double * : take pan law, -1=default, 0.5=-6dB, 1.0=+0dB, etc
D_PLAYRATE : double * : take playback rate, 0.5=half speed, 1=normal, 2=double speed, etc
D_PITCH : double * : take pitch adjustment in semitones, -12=one octave down, 0=normal, +12=one octave up, etc
B_PPITCH : bool * : preserve pitch when changing playback rate
I_LASTY : int * : Y-position (relative to top of track) in pixels (read-only)
I_LASTH : int * : height in pixels (read-only)
I_CHANMODE : int * : channel mode, 0=normal, 1=reverse stereo, 2=downmix, 3=left, 4=right
I_PITCHMODE : int * : pitch shifter mode, -1=project default, otherwise high 2 bytes=shifter, low 2 bytes=parameter
I_STRETCHFLAGS : int * : stretch marker flags (&7 mask for mode override: 0=default, 1=balanced, 2/3/6=tonal, 4=transient, 5=no pre-echo)
F_STRETCHFADESIZE : float * : stretch marker fade size in seconds (0.0025 default)
I_RECPASSID : int * : record pass ID
I_TAKEFX_NCH : int * : number of internal audio channels for per-take FX to use (OK to call with setNewValue, but the returned value is read-only)
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
IP_TAKENUMBER : int : take number (read-only, returns the take number directly)

bool SetMediaTrackInfo_Value(MediaTrack* tr, const char* parmname, double newvalue)
bool SetMediaTrackInfo_Value(MediaTrack tr, "parmname", newvalue)
boolean reaper.SetMediaTrackInfo_Value(MediaTrack tr, string parmname, number newvalue)
Boolean RPR_SetMediaTrackInfo_Value(MediaTrack tr, String parmname, Float newvalue)

Set track numerical-value attributes.
B_MUTE : bool * : muted
B_PHASE : bool * : track phase inverted
B_RECMON_IN_EFFECT : bool * : record monitoring in effect (current audio-thread playback state, read-only)
IP_TRACKNUMBER : int : track number 1-based, 0=not found, -1=master track (read-only, returns the int directly)
I_SOLO : int * : soloed, 0=not soloed, 1=soloed, 2=soloed in place, 5=safe soloed, 6=safe soloed in place
B_SOLO_DEFEAT : bool * : when set, if anything else is soloed and this track is not muted, this track acts soloed
I_FXEN : int * : fx enabled, 0=bypassed, !0=fx active
I_RECARM : int * : record armed, 0=not record armed, 1=record armed
I_RECINPUT : int * : record input, <0=no input. if 4096 set, input is MIDI and low 5 bits represent channel (0=all, 1-16=only chan), next 6 bits represent physical input (63=all, 62=VKB). If 4096 is not set, low 10 bits (0..1023) are input start channel (ReaRoute/Loopback start at 512). If 2048 is set, input is multichannel input (using track channel count), or if 1024 is set, input is stereo input, otherwise input is mono.
I_RECMODE : int * : record mode, 0=input, 1=stereo out, 2=none, 3=stereo out w/latency compensation, 4=midi output, 5=mono out, 6=mono out w/ latency compensation, 7=midi overdub, 8=midi replace
I_RECMODE_FLAGS : int * : record mode flags, &3=output recording mode (0=post fader, 1=pre-fx, 2=post-fx/pre-fader)
I_RECMON : int * : record monitoring, 0=off, 1=normal, 2=not when playing (tape style)
I_RECMONITEMS : int * : monitor items while recording, 0=off, 1=on
B_AUTO_RECARM : bool * : automatically set record arm when selected (does not immediately affect recarm state, script should set directly if desired)
I_VUMODE : int * : track vu mode, &1:disabled, &30==0:stereo peaks, &30==2:multichannel peaks, &30==4:stereo RMS, &30==8:combined RMS, &30==12:LUFS-M, &30==16:LUFS-S (readout=max), &30==20:LUFS-S (readout=current), &32:LUFS calculation on channels 1+2 only
I_AUTOMODE : int * : track automation mode, 0=trim/off, 1=read, 2=touch, 3=write, 4=latch
I_NCHAN : int * : number of track channels, 2-128, even numbers only
I_SELECTED : int * : track selected, 0=unselected, 1=selected
I_WNDH : int * : current TCP window height in pixels including envelopes (read-only)
I_TCPH : int * : current TCP window height in pixels not including envelopes (read-only)
I_TCPY : int * : current TCP window Y-position in pixels relative to top of arrange view (read-only)
I_MCPX : int * : current MCP X-position in pixels relative to mixer container (read-only)
I_MCPY : int * : current MCP Y-position in pixels relative to mixer container (read-only)
I_MCPW : int * : current MCP width in pixels (read-only)
I_MCPH : int * : current MCP height in pixels (read-only)
I_FOLDERDEPTH : int * : folder depth change, 0=normal, 1=track is a folder parent, -1=track is the last in the innermost folder, -2=track is the last in the innermost and next-innermost folders, etc
I_FOLDERCOMPACT : int * : folder collapsed state (only valid on folders), 0=normal, 1=collapsed, 2=fully collapsed
I_MIDIHWOUT : int * : track midi hardware output index, <0=disabled, low 5 bits are which channels (0=all, 1-16), next 5 bits are output device index (0-31)
I_PERFFLAGS : int * : track performance flags, &1=no media buffering, &2=no anticipative FX
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
I_HEIGHTOVERRIDE : int * : custom height override for TCP window, 0 for none, otherwise size in pixels
I_SPACER : int * : 1=TCP track spacer above this trackB_HEIGHTLOCK : bool * : track height lock (must set I_HEIGHTOVERRIDE before locking)
D_VOL : double * : trim volume of track, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc
D_PAN : double * : trim pan of track, -1..1
D_WIDTH : double * : width of track, -1..1
D_DUALPANL : double * : dualpan position 1, -1..1, only if I_PANMODE==6
D_DUALPANR : double * : dualpan position 2, -1..1, only if I_PANMODE==6
I_PANMODE : int * : pan mode, 0=classic 3.x, 3=new balance, 5=stereo pan, 6=dual pan
D_PANLAW : double * : pan law of track, <0=project default, 0.5=-6dB, 0.707..=-3dB, 1=+0dB, 1.414..=-3dB with gain compensation, 2=-6dB with gain compensation, etc
I_PANLAW_FLAGS : int * : pan law flags, 0=sine taper, 1=hybrid taper with deprecated behavior when gain compensation enabled, 2=linear taper, 3=hybrid taper
P_ENV:<envchunkname or P_ENV:{GUID... : TrackEnvelope * : (read-only) chunkname can be <VOLENV, <PANENV, etc; GUID is the stringified envelope GUID.
B_SHOWINMIXER : bool * : track control panel visible in mixer (do not use on master track)
B_SHOWINTCP : bool * : track control panel visible in arrange view (do not use on master track)
B_MAINSEND : bool * : track sends audio to parent
C_MAINSEND_OFFS : char * : channel offset of track send to parent
C_MAINSEND_NCH : char * : channel count of track send to parent (0=use all child track channels, 1=use one channel only)
I_FREEMODE : int * : 1=track free item positioning enabled, 2=track fixed lanes enabled (call UpdateTimeline() after changing)
I_NUMFIXEDLANES : int * : number of track fixed lanes (fine to call with setNewValue, but returned value is read-only)
C_LANESCOLLAPSED : char * : fixed lane collapse state (1=lanes collapsed, 2=track displays as non-fixed-lanes but hidden lanes exist)
C_LANEPLAYS:N : char * : on fixed lane tracks, 0=lane N does not play, 1=lane N plays exclusively, 2=lane N plays and other lanes also play (fine to call with setNewValue, but returned value is read-only)
C_ALLLANESPLAY : char * : on fixed lane tracks, 0=no lanes play, 1=all lanes play, 2=some lanes play (fine to call with setNewValue 0 or 1, but returned value is read-only)
C_BEATATTACHMODE : char * : track timebase, -1=project default, 0=time, 1=beats (position, length, rate), 2=beats (position only)
F_MCP_FXSEND_SCALE : float * : scale of fx+send area in MCP (0=minimum allowed, 1=maximum allowed)
F_MCP_FXPARM_SCALE : float * : scale of fx parameter area in MCP (0=minimum allowed, 1=maximum allowed)
F_MCP_SENDRGN_SCALE : float * : scale of send area as proportion of the fx+send total area (0=minimum allowed, 1=maximum allowed)
F_TCP_FXPARM_SCALE : float * : scale of TCP parameter area when TCP FX are embedded (0=min allowed, default, 1=max allowed)
I_PLAY_OFFSET_FLAG : int * : track media playback offset state, &1=bypassed, &2=offset value is measured in samples (otherwise measured in seconds)
D_PLAY_OFFSET : double * : track media playback offset, units depend on I_PLAY_OFFSET_FLAG

void SetMIDIEditorGrid(ReaProject* project, double division)
SetMIDIEditorGrid(ReaProject project, division)
reaper.SetMIDIEditorGrid(ReaProject project, number division)
RPR_SetMIDIEditorGrid(ReaProject project, Float division)

Set the MIDI editor grid division. 0.25=quarter note, 1.0/3.0=half note tripet, etc.

MediaTrack* SetMixerScroll(MediaTrack* leftmosttrack)
MediaTrack SetMixerScroll(MediaTrack leftmosttrack)
MediaTrack reaper.SetMixerScroll(MediaTrack leftmosttrack)
MediaTrack RPR_SetMixerScroll(MediaTrack leftmosttrack)

Scroll the mixer so that leftmosttrack is the leftmost visible track. Returns the leftmost track after scrolling, which may be different from the passed-in track if there are not enough tracks to its right.

void SetMouseModifier(const char* context, int modifier_flag, const char* action)
SetMouseModifier("context", int modifier_flag, "action")
reaper.SetMouseModifier(string context, integer modifier_flag, string action)
RPR_SetMouseModifier(String context, Int modifier_flag, String action)

Set the mouse modifier assignment for a specific modifier key assignment, in a specific context.
Context is a string like "MM_CTX_ITEM" (see reaper-mouse.ini) or "Media item left drag" (unlocalized).
Modifier flag is a number from 0 to 15: add 1 for shift, 2 for control, 4 for alt, 8 for win.
(macOS: add 1 for shift, 2 for command, 4 for opt, 8 for control.)
For left-click and double-click contexts, the action can be any built-in command ID number
or any custom action ID string. Find built-in command IDs in the REAPER actions window
(enable "show command IDs" in the context menu), and find custom action ID strings in reaper-kb.ini.
The action string may be a mouse modifier ID (see reaper-mouse.ini) with " m" appended to it,
or (for click/double-click contexts) a command ID with " c" appended to it,
or the text that appears in the mouse modifiers preferences dialog, like "Move item" (unlocalized).
For example, SetMouseModifier("MM_CTX_ITEM", 0, "1 m") and SetMouseModifier("Media item left drag", 0, "Move item") are equivalent.
SetMouseModifier(context, modifier_flag, -1) will reset that mouse modifier to default.
SetMouseModifier(context, -1, -1) will reset the entire context to default.
SetMouseModifier(-1, -1, -1) will reset all contexts to default.
See GetMouseModifier.

void SetOnlyTrackSelected(MediaTrack* track)
SetOnlyTrackSelected(MediaTrack track)
reaper.SetOnlyTrackSelected(MediaTrack track)
RPR_SetOnlyTrackSelected(MediaTrack track)

Set exactly one track selected, deselect all others

void SetProjectGrid(ReaProject* project, double division)
SetProjectGrid(ReaProject project, division)
reaper.SetProjectGrid(ReaProject project, number division)
RPR_SetProjectGrid(ReaProject project, Float division)

Set the arrange view grid division. 0.25=quarter note, 1.0/3.0=half note triplet, etc.

bool SetProjectMarker(int markrgnindexnumber, bool isrgn, double pos, double rgnend, const char* name)
bool SetProjectMarker(int markrgnindexnumber, bool isrgn, pos, rgnend, "name")
boolean reaper.SetProjectMarker(integer markrgnindexnumber, boolean isrgn, number pos, number rgnend, string name)
Boolean RPR_SetProjectMarker(Int markrgnindexnumber, Boolean isrgn, Float pos, Float rgnend, String name)

Note: this function can't clear a marker's name (an empty string will leave the name unchanged), see SetProjectMarker4.

bool SetProjectMarker2(ReaProject* proj, int markrgnindexnumber, bool isrgn, double pos, double rgnend, const char* name)
bool SetProjectMarker2(ReaProject proj, int markrgnindexnumber, bool isrgn, pos, rgnend, "name")
boolean reaper.SetProjectMarker2(ReaProject proj, integer markrgnindexnumber, boolean isrgn, number pos, number rgnend, string name)
Boolean RPR_SetProjectMarker2(ReaProject proj, Int markrgnindexnumber, Boolean isrgn, Float pos, Float rgnend, String name)

Note: this function can't clear a marker's name (an empty string will leave the name unchanged), see SetProjectMarker4.

bool SetProjectMarker3(ReaProject* proj, int markrgnindexnumber, bool isrgn, double pos, double rgnend, const char* name, int color)
bool SetProjectMarker3(ReaProject proj, int markrgnindexnumber, bool isrgn, pos, rgnend, "name", int color)
boolean reaper.SetProjectMarker3(ReaProject proj, integer markrgnindexnumber, boolean isrgn, number pos, number rgnend, string name, integer color)
Boolean RPR_SetProjectMarker3(ReaProject proj, Int markrgnindexnumber, Boolean isrgn, Float pos, Float rgnend, String name, Int color)

Note: this function can't clear a marker's name (an empty string will leave the name unchanged), see SetProjectMarker4.

bool SetProjectMarker4(ReaProject* proj, int markrgnindexnumber, bool isrgn, double pos, double rgnend, const char* name, int color, int flags)
bool SetProjectMarker4(ReaProject proj, int markrgnindexnumber, bool isrgn, pos, rgnend, "name", int color, int flags)
boolean reaper.SetProjectMarker4(ReaProject proj, integer markrgnindexnumber, boolean isrgn, number pos, number rgnend, string name, integer color, integer flags)
Boolean RPR_SetProjectMarker4(ReaProject proj, Int markrgnindexnumber, Boolean isrgn, Float pos, Float rgnend, String name, Int color, Int flags)

color should be 0 to not change, or ColorToNative(r,g,b)|0x1000000, flags&1 to clear name

bool SetProjectMarkerByIndex(ReaProject* proj, int markrgnidx, bool isrgn, double pos, double rgnend, int IDnumber, const char* name, int color)
bool SetProjectMarkerByIndex(ReaProject proj, int markrgnidx, bool isrgn, pos, rgnend, int IDnumber, "name", int color)
boolean reaper.SetProjectMarkerByIndex(ReaProject proj, integer markrgnidx, boolean isrgn, number pos, number rgnend, integer IDnumber, string name, integer color)
Boolean RPR_SetProjectMarkerByIndex(ReaProject proj, Int markrgnidx, Boolean isrgn, Float pos, Float rgnend, Int IDnumber, String name, Int color)

See SetProjectMarkerByIndex2.

bool SetProjectMarkerByIndex2(ReaProject* proj, int markrgnidx, bool isrgn, double pos, double rgnend, int IDnumber, const char* name, int color, int flags)
bool SetProjectMarkerByIndex2(ReaProject proj, int markrgnidx, bool isrgn, pos, rgnend, int IDnumber, "name", int color, int flags)
boolean reaper.SetProjectMarkerByIndex2(ReaProject proj, integer markrgnidx, boolean isrgn, number pos, number rgnend, integer IDnumber, string name, integer color, integer flags)
Boolean RPR_SetProjectMarkerByIndex2(ReaProject proj, Int markrgnidx, Boolean isrgn, Float pos, Float rgnend, Int IDnumber, String name, Int color, Int flags)

Differs from SetProjectMarker4 in that markrgnidx is 0 for the first marker/region, 1 for the next, etc (see EnumProjectMarkers3), rather than representing the displayed marker/region ID number (see SetProjectMarker3). Function will fail if attempting to set a duplicate ID number for a region (duplicate ID numbers for markers are OK). , flags&1 to clear name. If flags&2, markers will not be re-sorted, and after making updates, you MUST call SetProjectMarkerByIndex2 with markrgnidx=-1 and flags&2 to force re-sort/UI updates.

int SetProjExtState(ReaProject* proj, const char* extname, const char* key, const char* value)
int SetProjExtState(ReaProject proj, "extname", "key", "value")
integer reaper.SetProjExtState(ReaProject proj, string extname, string key, string value)
Int RPR_SetProjExtState(ReaProject proj, String extname, String key, String value)

Save a key/value pair for a specific extension, to be restored the next time this specific project is loaded. Typically extname will be the name of a reascript or extension section. If key is NULL or "", all extended data for that extname will be deleted. If val is NULL or "", the data previously associated with that key will be deleted. Returns the size of the state for this extname. See GetProjExtState, EnumProjExtState.

void SetRegionRenderMatrix(ReaProject* proj, int regionindex, MediaTrack* track, int flag)
SetRegionRenderMatrix(ReaProject proj, int regionindex, MediaTrack track, int flag)
reaper.SetRegionRenderMatrix(ReaProject proj, integer regionindex, MediaTrack track, integer flag)
RPR_SetRegionRenderMatrix(ReaProject proj, Int regionindex, MediaTrack track, Int flag)

Add (flag > 0) or remove (flag < 0) a track from this region when using the region render matrix. If adding, flag==2 means force mono, flag==4 means force stereo, flag==N means force N/2 channels.

int SetTakeMarker(MediaItem_Take* take, int idx, const char* nameIn, double* srcposInOptional, int* colorInOptional)
int SetTakeMarker(MediaItem_Take take, int idx, "nameIn", optional srcposIn, optional int colorIn)
integer reaper.SetTakeMarker(MediaItem_Take take, integer idx, string nameIn, optional number srcposIn, optional integer colorIn)
(Int retval, MediaItem_Take take, Int idx, String nameIn, Float srcposInOptional, Int colorInOptional) = RPR_SetTakeMarker(take, idx, nameIn, srcposInOptional, colorInOptional)

Inserts or updates a take marker. If idx<0, a take marker will be added, otherwise an existing take marker will be updated. Returns the index of the new or updated take marker (which may change if srcPos is updated). See GetNumTakeMarkers, GetTakeMarker, DeleteTakeMarker

int SetTakeStretchMarker(MediaItem_Take* take, int idx, double pos, const double* srcposInOptional)
int SetTakeStretchMarker(MediaItem_Take take, int idx, pos, optional srcposIn)
integer reaper.SetTakeStretchMarker(MediaItem_Take take, integer idx, number pos, optional number srcposIn)
Int RPR_SetTakeStretchMarker(MediaItem_Take take, Int idx, Float pos, const double srcposInOptional)

Adds or updates a stretch marker. If idx<0, stretch marker will be added. If idx>=0, stretch marker will be updated. When adding, if srcposInOptional is omitted, source position will be auto-calculated. When updating a stretch marker, if srcposInOptional is omitted, srcpos will not be modified. Position/srcposition values will be constrained to nearby stretch markers. Returns index of stretch marker, or -1 if did not insert (or marker already existed at time).

bool SetTakeStretchMarkerSlope(MediaItem_Take* take, int idx, double slope)
bool SetTakeStretchMarkerSlope(MediaItem_Take take, int idx, slope)
boolean reaper.SetTakeStretchMarkerSlope(MediaItem_Take take, integer idx, number slope)
Boolean RPR_SetTakeStretchMarkerSlope(MediaItem_Take take, Int idx, Float slope)

See GetTakeStretchMarkerSlope

bool SetTempoTimeSigMarker(ReaProject* proj, int ptidx, double timepos, int measurepos, double beatpos, double bpm, int timesig_num, int timesig_denom, bool lineartempo)
bool SetTempoTimeSigMarker(ReaProject proj, int ptidx, timepos, int measurepos, beatpos, bpm, int timesig_num, int timesig_denom, bool lineartempo)
boolean reaper.SetTempoTimeSigMarker(ReaProject proj, integer ptidx, number timepos, integer measurepos, number beatpos, number bpm, integer timesig_num, integer timesig_denom, boolean lineartempo)
Boolean RPR_SetTempoTimeSigMarker(ReaProject proj, Int ptidx, Float timepos, Int measurepos, Float beatpos, Float bpm, Int timesig_num, Int timesig_denom, Boolean lineartempo)

Set parameters of a tempo/time signature marker. Provide either timepos (with measurepos=-1, beatpos=-1), or measurepos and beatpos (with timepos=-1). If timesig_num and timesig_denom are zero, the previous time signature will be used. ptidx=-1 will insert a new tempo/time signature marker. See CountTempoTimeSigMarkers, GetTempoTimeSigMarker, AddTempoTimeSigMarker.

int SetThemeColor(const char* ini_key, int color, int flagsOptional)
int SetThemeColor("ini_key", int color, int flags)
integer reaper.SetThemeColor(string ini_key, integer color, integer flags)
Int RPR_SetThemeColor(String ini_key, Int color, Int flagsOptional)

Temporarily updates the theme color to the color specified (or the theme default color if -1 is specified). Returns -1 on failure, otherwise returns the color (or transformed-color). Note that the UI is not updated by this, the caller should call UpdateArrange() etc as necessary. If the low bit of flags is set, any color transformations are bypassed. To read a value see GetThemeColor.
Currently valid ini_keys:

  • col_main_bg2 : Main window/transport background -- current RGB: 51,51,51
  • col_main_text2 : Main window/transport text -- current RGB: 170,170,170
  • col_main_textshadow : Main window text shadow (ignored if too close to text color) -- current RGB: 18,26,29
  • col_main_3dhl : Main window 3D highlight -- current RGB: 70,70,70
  • col_main_3dsh : Main window 3D shadow -- current RGB: 45,45,45
  • col_main_resize2 : Main window pane resize mouseover -- current RGB: 51,51,51
  • col_main_text : Themed window text -- current RGB: 18,18,18
  • col_main_bg : Themed window background -- current RGB: 123,123,123
  • col_main_editbk : Themed window edit background -- current RGB: 170,170,170
  • col_nodarkmodemiscwnd : Do not use window theming on macOS dark mode -- bool 00000000
  • col_transport_editbk : Transport edit background -- current RGB: 51,51,51
  • col_toolbar_text : Toolbar button text -- current RGB: 159,159,159
  • col_toolbar_text_on : Toolbar button enabled text -- current RGB: 191,251,192
  • col_toolbar_frame : Toolbar frame when floating or docked -- current RGB: 71,78,78
  • toolbararmed_color : Toolbar button armed color -- current RGB: 255,128,0
  • toolbararmed_drawmode : Toolbar button armed fill mode -- blendmode 00028001
  • io_text : I/O window text -- current RGB: 69,69,69
  • io_3dhl : I/O window 3D highlight -- current RGB: 131,131,131
  • io_3dsh : I/O window 3D shadow -- current RGB: 204,204,204
  • genlist_bg : Window list background -- current RGB: 170,170,170
  • genlist_fg : Window list text -- current RGB: 18,18,18
  • genlist_grid : Window list grid lines -- current RGB: 132,132,132
  • genlist_selbg : Window list selected row -- current RGB: 87,87,87
  • genlist_selfg : Window list selected text -- current RGB: 255,255,255
  • genlist_seliabg : Window list selected row (inactive) -- current RGB: 240,240,240
  • genlist_seliafg : Window list selected text (inactive) -- current RGB: 0,0,0
  • genlist_hilite : Window list highlighted text -- current RGB: 0,0,224
  • genlist_hilite_sel : Window list highlighted selected text -- current RGB: 192,192,255
  • col_buttonbg : Button background -- current RGB: 0,0,0
  • col_tcp_text : Track panel text -- current RGB: 18,26,29
  • col_tcp_textsel : Track panel (selected) text -- current RGB: 18,26,29
  • col_seltrack : Selected track control panel background -- current RGB: 210,210,210
  • col_seltrack2 : Unselected track control panel background (enabled with a checkbox above) -- current RGB: 197,197,197
  • tcplocked_color : Locked track control panel overlay color -- current RGB: 51,51,51
  • tcplocked_drawmode : Locked track control panel fill mode -- blendmode 0002c000
  • col_tracklistbg : Empty track list area -- current RGB: 51,51,51
  • col_mixerbg : Empty mixer list area -- current RGB: 51,51,51
  • col_arrangebg : Empty arrange view area -- current RGB: 41,41,41
  • arrange_vgrid : Empty arrange view area vertical grid shading -- current RGB: 41,41,41
  • col_fadearm : Fader background when automation recording -- current RGB: 255,125,125
  • col_fadearm2 : Fader background when automation playing -- current RGB: 125,255,125
  • col_fadearm3 : Fader background when in inactive touch/latch -- current RGB: 255,255,98
  • col_tl_fg : Timeline foreground -- current RGB: 105,107,107
  • col_tl_fg2 : Timeline foreground (secondary markings) -- current RGB: 76,77,77
  • col_tl_bg : Timeline background -- current RGB: 48,48,48
  • col_tl_bgsel : Time selection color -- current RGB: 255,255,255
  • timesel_drawmode : Time selection fill mode -- blendmode 00020f01
  • col_tl_bgsel2 : Timeline background (in loop points) -- current RGB: 192,192,192
  • col_trans_bg : Transport status background -- current RGB: 73,73,73
  • col_trans_fg : Transport status text -- current RGB: 137,139,139
  • playrate_edited : Project play rate control when not 1.0 -- current RGB: 127,63,0
  • selitem_dot : Media item selection indicator -- current RGB: 255,255,255
  • col_mi_label : Media item label -- current RGB: 170,170,170
  • col_mi_label_sel : Media item label (selected) -- current RGB: 170,170,170
  • col_mi_label_float : Floating media item label -- current RGB: 170,170,170
  • col_mi_label_float_sel : Floating media item label (selected) -- current RGB: 170,170,170
  • col_mi_bg : Media item background (odd tracks) -- current RGB: 125,125,125
  • col_mi_bg2 : Media item background (even tracks) -- current RGB: 125,125,125
  • col_tr1_itembgsel : Media item background selected (odd tracks) -- current RGB: 106,255,163
  • col_tr2_itembgsel : Media item background selected (even tracks) -- current RGB: 106,255,163
  • itembg_drawmode : Media item background fill mode -- blendmode 00028000
  • col_tr1_peaks : Media item peaks (odd tracks) -- current RGB: 21,21,21
  • col_tr2_peaks : Media item peaks (even tracks) -- current RGB: 21,21,21
  • col_tr1_ps2 : Media item peaks when selected (odd tracks) -- current RGB: 21,21,21
  • col_tr2_ps2 : Media item peaks when selected (even tracks) -- current RGB: 21,21,21
  • col_peaksedge : Media item peaks edge highlight (odd tracks) -- current RGB: 51,51,51
  • col_peaksedge2 : Media item peaks edge highlight (even tracks) -- current RGB: 51,51,51
  • col_peaksedgesel : Media item peaks edge highlight when selected (odd tracks) -- current RGB: 51,51,51
  • col_peaksedgesel2 : Media item peaks edge highlight when selected (even tracks) -- current RGB: 51,51,51
  • cc_chase_drawmode : Media item MIDI CC peaks fill mode -- blendmode 00024000
  • col_peaksfade : Media item peaks when active in crossfade editor (fade-out) -- current RGB: 0,255,0
  • col_peaksfade2 : Media item peaks when active in crossfade editor (fade-in) -- current RGB: 255,0,0
  • col_mi_fades : Media item fade/volume controls -- current RGB: 105,16,16
  • fadezone_color : Media item fade quiet zone fill color -- current RGB: 72,0,0
  • fadezone_drawmode : Media item fade quiet zone fill mode -- blendmode 00030004
  • fadearea_color : Media item fade full area fill color -- current RGB: 0,0,96
  • fadearea_drawmode : Media item fade full area fill mode -- blendmode 00020000
  • col_mi_fade2 : Media item edges of controls -- current RGB: 198,198,198
  • col_mi_fade2_drawmode : Media item edges of controls blend mode -- blendmode 00025901
  • item_grouphl : Media item edge when selected via grouping -- current RGB: 51,184,48
  • col_offlinetext : Media item "offline" text -- current RGB: 48,66,71
  • col_stretchmarker : Media item stretch marker line -- current RGB: 84,124,124
  • col_stretchmarker_h0 : Media item stretch marker handle (1x) -- current RGB: 120,135,135
  • col_stretchmarker_h1 : Media item stretch marker handle (>1x) -- current RGB: 40,141,196
  • col_stretchmarker_h2 : Media item stretch marker handle (<1x) -- current RGB: 159,64,64
  • col_stretchmarker_b : Media item stretch marker handle edge -- current RGB: 192,192,192
  • col_stretchmarkerm : Media item stretch marker blend mode -- blendmode 00030000
  • col_stretchmarker_text : Media item stretch marker text -- current RGB: 126,153,154
  • col_stretchmarker_tm : Media item transient guide handle -- current RGB: 0,234,0
  • take_marker : Media item take marker -- current RGB: 255,255,0
  • selitem_tag : Selected media item bar color -- current RGB: 0,0,0
  • activetake_tag : Active media item take bar color -- current RGB: 0,0,0
  • col_tr1_bg : Track background (odd tracks) -- current RGB: 41,41,41
  • col_tr2_bg : Track background (even tracks) -- current RGB: 41,41,41
  • selcol_tr1_bg : Selected track background (odd tracks) -- current RGB: 41,41,41
  • selcol_tr2_bg : Selected track background (even tracks) -- current RGB: 41,41,41
  • track_lane_tabcol : Track fixed lane button -- current RGB: 87,96,87
  • track_lanesolo_tabcol : Track fixed lane button when only this lane plays -- current RGB: 201,201,38
  • track_lanesolo_text : Track fixed lane button text -- current RGB: 200,200,200
  • track_lane_gutter : Track fixed lane add area -- current RGB: 128,128,128
  • track_lane_gutter_drawmode : Track fixed lane add fill mode -- blendmode 00024000
  • col_tr1_divline : Track divider line (odd tracks) -- current RGB: 67,67,67
  • col_tr2_divline : Track divider line (even tracks) -- current RGB: 67,67,67
  • col_envlane1_divline : Envelope lane divider line (odd tracks) -- current RGB: 0,0,0
  • col_envlane2_divline : Envelope lane divider line (even tracks) -- current RGB: 0,0,0
  • mute_overlay_col : Muted/unsoloed track/item overlay color -- current RGB: 65,65,65
  • mute_overlay_mode : Muted/unsoloed track/item overlay mode -- blendmode 0002a600
  • inactive_take_overlay_col : Inactive take/lane overlay color -- current RGB: 48,48,48
  • inactive_take_overlay_mode : Inactive take/lane overlay mode -- blendmode 00028000
  • locked_overlay_col : Locked track/item overlay color -- current RGB: 0,0,0
  • locked_overlay_mode : Locked track/item overlay mode -- blendmode 00025c03
  • marquee_fill : Marquee fill -- current RGB: 128,128,110
  • marquee_drawmode : Marquee fill mode -- blendmode 000299ff
  • marquee_outline : Marquee outline -- current RGB: 255,255,255
  • marqueezoom_fill : Marquee zoom fill -- current RGB: 255,255,255
  • marqueezoom_drawmode : Marquee zoom fill mode -- blendmode 00024002
  • marqueezoom_outline : Marquee zoom outline -- current RGB: 0,255,0
  • areasel_fill : Razor edit area fill -- current RGB: 31,233,192
  • areasel_drawmode : Razor edit area fill mode -- blendmode 00021c01
  • areasel_outline : Razor edit area outline -- current RGB: 0,251,201
  • areasel_outlinemode : Razor edit area outline mode -- blendmode 0002c000
  • linkedlane_fill : Fixed lane comp area fill -- current RGB: 255,203,0
  • linkedlane_fillmode : Fixed lane comp area fill mode -- blendmode 00020c01
  • linkedlane_outline : Fixed lane comp area outline -- current RGB: 255,237,164
  • linkedlane_outlinemode : Fixed lane comp area outline mode -- blendmode 0002c000
  • linkedlane_unsynced : Fixed lane comp lane unsynced media item -- current RGB: 0,198,255
  • linkedlane_unsynced_mode : Fixed lane comp lane unsynced media item mode -- blendmode 0002ff00
  • col_cursor : Edit cursor -- current RGB: 220,36,36
  • col_cursor2 : Edit cursor (alternate) -- current RGB: 220,36,36
  • playcursor_color : Play cursor -- current RGB: 0,0,0
  • playcursor_drawmode : Play cursor fill mode -- blendmode 00028003
  • col_gridlines2 : Grid lines (start of measure) -- current RGB: 138,69,0
  • col_gridlines2dm : Grid lines (start of measure) - draw mode -- blendmode 0002c001
  • col_gridlines3 : Grid lines (start of beats) -- current RGB: 73,73,73
  • col_gridlines3dm : Grid lines (start of beats) - draw mode -- blendmode 00028001
  • col_gridlines : Grid lines (in between beats) -- current RGB: 50,50,50
  • col_gridlines1dm : Grid lines (in between beats) - draw mode -- blendmode 00028001
  • guideline_color : Editing guide line color -- current RGB: 95,169,167
  • guideline_drawmode : Editing guide fill mode -- blendmode 00024c01
  • region : Regions -- current RGB: 128,138,138
  • region_lane_bg : Region lane background -- current RGB: 51,51,51
  • region_lane_text : Region lane text -- current RGB: 31,39,37
  • marker : Markers -- current RGB: 75,0,0
  • marker_lane_bg : Marker lane background -- current RGB: 73,73,73
  • marker_lane_text : Marker lane text -- current RGB: 165,165,165
  • col_tsigmark : Time signature change marker -- current RGB: 170,170,170
  • ts_lane_bg : Time signature lane background -- current RGB: 51,51,51
  • ts_lane_text : Time signature lane text -- current RGB: 165,165,165
  • timesig_sel_bg : Time signature marker selected background -- current RGB: 70,0,0
  • col_routinghl1 : Routing matrix row highlight -- current RGB: 255,255,192
  • col_routinghl2 : Routing matrix column highlight -- current RGB: 128,128,255
  • col_routingact : Routing matrix input activity highlight -- current RGB: 64,255,64
  • col_vudoint : Theme has interlaced VU meters -- bool 00000000
  • col_vuclip : VU meter clip indicator -- current RGB: 255,0,0
  • col_vutop : VU meter top -- current RGB: 255,128,0
  • col_vumid : VU meter middle -- current RGB: 255,255,0
  • col_vubot : VU meter bottom -- current RGB: 0,191,191
  • col_vuintcol : VU meter interlace/edge color -- current RGB: 32,32,32
  • vu_gr_bgcol : VU meter gain reduction background -- current RGB: 32,32,32
  • vu_gr_fgcol : VU meter gain reduction indicator -- current RGB: 224,224,0
  • col_vumidi : VU meter midi activity -- current RGB: 255,0,0
  • col_vuind1 : VU (indicator) - no signal -- current RGB: 32,32,32
  • col_vuind2 : VU (indicator) - low signal -- current RGB: 213,0,0
  • col_vuind3 : VU (indicator) - med signal -- current RGB: 255,128,0
  • col_vuind4 : VU (indicator) - hot signal -- current RGB: 255,255,0
  • mcp_sends_normal : Sends text: normal -- current RGB: 163,163,163
  • mcp_sends_muted : Sends text: muted -- current RGB: 152,134,99
  • mcp_send_midihw : Sends text: MIDI hardware -- current RGB: 163,163,163
  • mcp_sends_levels : Sends level -- current RGB: 48,66,71
  • mcp_fx_normal : FX insert text: normal -- current RGB: 201,164,107
  • mcp_fx_bypassed : FX insert text: bypassed -- current RGB: 140,140,140
  • mcp_fx_offlined : FX insert text: offline -- current RGB: 183,68,68
  • mcp_fxparm_normal : FX parameter text: normal -- current RGB: 163,163,163
  • mcp_fxparm_bypassed : FX parameter text: bypassed -- current RGB: 152,134,99
  • mcp_fxparm_offlined : FX parameter text: offline -- current RGB: 152,99,99
  • tcp_list_scrollbar : List scrollbar (track panel) -- current RGB: 50,50,50
  • tcp_list_scrollbar_mode : List scrollbar (track panel) - draw mode -- blendmode 00028000
  • tcp_list_scrollbar_mouseover : List scrollbar mouseover (track panel) -- current RGB: 30,30,30
  • tcp_list_scrollbar_mouseover_mode : List scrollbar mouseover (track panel) - draw mode -- blendmode 00028000
  • mcp_list_scrollbar : List scrollbar (mixer panel) -- current RGB: 140,140,140
  • mcp_list_scrollbar_mode : List scrollbar (mixer panel) - draw mode -- blendmode 00028000
  • mcp_list_scrollbar_mouseover : List scrollbar mouseover (mixer panel) -- current RGB: 64,191,159
  • mcp_list_scrollbar_mouseover_mode : List scrollbar mouseover (mixer panel) - draw mode -- blendmode 00028000
  • midi_rulerbg : MIDI editor ruler background -- current RGB: 51,51,51
  • midi_rulerfg : MIDI editor ruler text -- current RGB: 127,127,127
  • midi_grid2 : MIDI editor grid line (start of measure) -- current RGB: 138,69,0
  • midi_griddm2 : MIDI editor grid line (start of measure) - draw mode -- blendmode 00030000
  • midi_grid3 : MIDI editor grid line (start of beats) -- current RGB: 91,91,91
  • midi_griddm3 : MIDI editor grid line (start of beats) - draw mode -- blendmode 00030000
  • midi_grid1 : MIDI editor grid line (between beats) -- current RGB: 91,91,91
  • midi_griddm1 : MIDI editor grid line (between beats) - draw mode -- blendmode 00028000
  • midi_trackbg1 : MIDI editor background color (naturals) -- current RGB: 48,48,48
  • midi_trackbg2 : MIDI editor background color (sharps/flats) -- current RGB: 41,41,41
  • midi_trackbg_outer1 : MIDI editor background color, out of bounds (naturals) -- current RGB: 31,31,31
  • midi_trackbg_outer2 : MIDI editor background color, out of bounds (sharps/flats) -- current RGB: 24,24,24
  • midi_selpitch1 : MIDI editor background color, selected pitch (naturals) -- current RGB: 87,57,57
  • midi_selpitch2 : MIDI editor background color, selected pitch (sharps/flats) -- current RGB: 75,52,52
  • midi_selbg : MIDI editor time selection color -- current RGB: 255,255,255
  • midi_selbg_drawmode : MIDI editor time selection fill mode -- blendmode 00020c01
  • midi_gridhc : MIDI editor CC horizontal center line -- current RGB: 157,157,157
  • midi_gridhcdm : MIDI editor CC horizontal center line - draw mode -- blendmode 00030000
  • midi_gridh : MIDI editor CC horizontal line -- current RGB: 91,91,91
  • midi_gridhdm : MIDI editor CC horizontal line - draw mode -- blendmode 00028000
  • midi_ccbut : MIDI editor CC lane add/remove buttons -- current RGB: 123,123,123
  • midi_ccbut_text : MIDI editor CC lane button text -- current RGB: 170,170,170
  • midi_ccbut_arrow : MIDI editor CC lane button arrow -- current RGB: 170,170,170
  • midioct : MIDI editor octave line color -- current RGB: 73,73,73
  • midi_inline_trackbg1 : MIDI inline background color (naturals) -- current RGB: 48,48,48
  • midi_inline_trackbg2 : MIDI inline background color (sharps/flats) -- current RGB: 41,41,41
  • midioct_inline : MIDI inline octave line color -- current RGB: 73,73,73
  • midi_endpt : MIDI editor end marker -- current RGB: 58,58,58
  • midi_notebg : MIDI editor note, unselected (midi_note_colormap overrides) -- current RGB: 91,123,108
  • midi_notefg : MIDI editor note, selected (midi_note_colormap overrides) -- current RGB: 49,49,49
  • midi_notemute : MIDI editor note, muted, unselected (midi_note_colormap overrides) -- current RGB: 53,53,53
  • midi_notemute_sel : MIDI editor note, muted, selected (midi_note_colormap overrides) -- current RGB: 24,24,24
  • midi_itemctl : MIDI editor note controls -- current RGB: 53,53,53
  • midi_ofsn : MIDI editor note (offscreen) -- current RGB: 59,59,59
  • midi_ofsnsel : MIDI editor note (offscreen, selected) -- current RGB: 59,59,59
  • midi_editcurs : MIDI editor cursor -- current RGB: 220,36,36
  • midi_pkey1 : MIDI piano key color (naturals background, sharps/flats text) -- current RGB: 255,255,255
  • midi_pkey2 : MIDI piano key color (sharps/flats background, naturals text) -- current RGB: 0,0,0
  • midi_pkey3 : MIDI piano key color (selected) -- current RGB: 93,93,93
  • midi_noteon_flash : MIDI piano key note-on flash -- current RGB: 188,148,39
  • midi_leftbg : MIDI piano pane background -- current RGB: 53,53,53
  • midifont_col_light_unsel : MIDI editor note text and control color, unselected (light) -- current RGB: 224,224,224
  • midifont_col_dark_unsel : MIDI editor note text and control color, unselected (dark) -- current RGB: 32,32,32
  • midifont_mode_unsel : MIDI editor note text and control mode, unselected -- blendmode 0002c000
  • midifont_col_light : MIDI editor note text and control color (light) -- current RGB: 189,189,189
  • midifont_col_dark : MIDI editor note text and control color (dark) -- current RGB: 64,64,64
  • midifont_mode : MIDI editor note text and control mode -- blendmode 00030000
  • score_bg : MIDI notation editor background -- current RGB: 255,255,255
  • score_fg : MIDI notation editor staff/notation/text -- current RGB: 0,0,0
  • score_sel : MIDI notation editor selected staff/notation/text -- current RGB: 0,0,255
  • score_timesel : MIDI notation editor time selection -- current RGB: 255,255,224
  • score_loop : MIDI notation editor loop points, selected pitch -- current RGB: 255,192,0
  • midieditorlist_bg : MIDI list editor background -- current RGB: 53,53,53
  • midieditorlist_fg : MIDI list editor text -- current RGB: 170,170,170
  • midieditorlist_grid : MIDI list editor grid lines -- current RGB: 53,53,53
  • midieditorlist_selbg : MIDI list editor selected row -- current RGB: 51,153,255
  • midieditorlist_selfg : MIDI list editor selected text -- current RGB: 255,255,255
  • midieditorlist_seliabg : MIDI list editor selected row (inactive) -- current RGB: 240,240,240
  • midieditorlist_seliafg : MIDI list editor selected text (inactive) -- current RGB: 0,0,0
  • midieditorlist_bg2 : MIDI list editor background (secondary) -- current RGB: 53,53,53
  • midieditorlist_fg2 : MIDI list editor text (secondary) -- current RGB: 0,0,0
  • midieditorlist_selbg2 : MIDI list editor selected row (secondary) -- current RGB: 35,135,240
  • midieditorlist_selfg2 : MIDI list editor selected text (secondary) -- current RGB: 255,255,255
  • col_explorer_sel : Media explorer selection -- current RGB: 255,255,255
  • col_explorer_seldm : Media explorer selection mode -- blendmode 00021501
  • col_explorer_seledge : Media explorer selection edge -- current RGB: 255,255,255
  • explorer_grid : Media explorer grid, markers -- current RGB: 255,255,255
  • explorer_pitchtext : Media explorer pitch detection text -- current RGB: 255,255,255
  • docker_shadow : Tab control shadow -- current RGB: 18,26,29
  • docker_selface : Tab control selected tab -- current RGB: 74,74,74
  • docker_unselface : Tab control unselected tab -- current RGB: 51,51,51
  • docker_text : Tab control text -- current RGB: 51,51,51
  • docker_text_sel : Tab control text selected tab -- current RGB: 51,51,51
  • docker_bg : Tab control background -- current RGB: 66,66,66
  • windowtab_bg : Tab control background in windows -- current RGB: 120,120,120
  • auto_item_unsel : Envelope: Unselected automation item -- current RGB: 96,96,96
  • col_env1 : Envelope: Volume (pre-FX) -- current RGB: 0,220,128
  • col_env2 : Envelope: Volume -- current RGB: 0,213,27
  • env_trim_vol : Envelope: Trim Volume -- current RGB: 213,0,106
  • col_env3 : Envelope: Pan (pre-FX) -- current RGB: 255,0,0
  • col_env4 : Envelope: Pan -- current RGB: 255,150,0
  • env_track_mute : Envelope: Mute -- current RGB: 213,0,159
  • col_env5 : Envelope: Master playrate -- current RGB: 213,0,106
  • col_env6 : Envelope: Master tempo -- current RGB: 0,255,255
  • col_env7 : Envelope: Width / Send volume -- current RGB: 213,0,0
  • col_env8 : Envelope: Send pan -- current RGB: 0,128,128
  • col_env9 : Envelope: Send volume 2 -- current RGB: 128,0,0
  • col_env10 : Envelope: Send pan 2 -- current RGB: 0,128,128
  • env_sends_mute : Envelope: Send mute -- current RGB: 192,192,0
  • col_env11 : Envelope: Audio hardware output volume -- current RGB: 0,255,255
  • col_env12 : Envelope: Audio hardware output pan -- current RGB: 255,255,0
  • col_env13 : Envelope: FX parameter 1 -- current RGB: 168,0,255
  • col_env14 : Envelope: FX parameter 2 -- current RGB: 48,146,147
  • col_env15 : Envelope: FX parameter 3 -- current RGB: 0,130,255
  • col_env16 : Envelope: FX parameter 4 -- current RGB: 192,39,69
  • env_item_vol : Envelope: Item take volume -- current RGB: 128,0,0
  • env_item_pan : Envelope: Item take pan -- current RGB: 0,128,128
  • env_item_mute : Envelope: Item take mute -- current RGB: 192,192,0
  • env_item_pitch : Envelope: Item take pitch -- current RGB: 0,255,255
  • wiring_grid2 : Wiring: Background -- current RGB: 46,46,46
  • wiring_grid : Wiring: Background grid lines -- current RGB: 51,51,51
  • wiring_border : Wiring: Box border -- current RGB: 153,153,153
  • wiring_tbg : Wiring: Box background -- current RGB: 38,38,38
  • wiring_ticon : Wiring: Box foreground -- current RGB: 204,204,204
  • wiring_recbg : Wiring: Record section background -- current RGB: 101,77,77
  • wiring_recitem : Wiring: Record section foreground -- current RGB: 63,33,33
  • wiring_media : Wiring: Media -- current RGB: 32,64,32
  • wiring_recv : Wiring: Receives -- current RGB: 92,92,92
  • wiring_send : Wiring: Sends -- current RGB: 92,92,92
  • wiring_fader : Wiring: Fader -- current RGB: 128,128,192
  • wiring_parent : Wiring: Master/Parent -- current RGB: 64,128,128
  • wiring_parentwire_border : Wiring: Master/Parent wire border -- current RGB: 100,100,100
  • wiring_parentwire_master : Wiring: Master/Parent to master wire -- current RGB: 192,192,192
  • wiring_parentwire_folder : Wiring: Master/Parent to parent folder wire -- current RGB: 128,128,128
  • wiring_pin_normal : Wiring: Pins normal -- current RGB: 192,192,192
  • wiring_pin_connected : Wiring: Pins connected -- current RGB: 96,144,96
  • wiring_pin_disconnected : Wiring: Pins disconnected -- current RGB: 64,32,32
  • wiring_horz_col : Wiring: Horizontal pin connections -- current RGB: 72,72,72
  • wiring_sendwire : Wiring: Send hanging wire -- current RGB: 128,128,128
  • wiring_hwoutwire : Wiring: Hardware output wire -- current RGB: 128,128,128
  • wiring_recinputwire : Wiring: Record input wire -- current RGB: 255,128,128
  • wiring_hwout : Wiring: System hardware outputs -- current RGB: 64,64,64
  • wiring_recinput : Wiring: System record inputs -- current RGB: 128,64,64
  • wiring_activity : Wiring: Activity lights -- current RGB: 64,255,64
  • autogroup : Automatic track group -- current RGB: 255,255,255
  • group_0 : Group #1 -- current RGB: 255,0,0
  • group_1 : Group #2 -- current RGB: 0,255,0
  • group_2 : Group #3 -- current RGB: 0,0,255
  • group_3 : Group #4 -- current RGB: 255,255,0
  • group_4 : Group #5 -- current RGB: 255,0,255
  • group_5 : Group #6 -- current RGB: 0,255,255
  • group_6 : Group #7 -- current RGB: 192,0,0
  • group_7 : Group #8 -- current RGB: 0,192,0
  • group_8 : Group #9 -- current RGB: 0,0,192
  • group_9 : Group #10 -- current RGB: 192,192,0
  • group_10 : Group #11 -- current RGB: 192,0,192
  • group_11 : Group #12 -- current RGB: 0,192,192
  • group_12 : Group #13 -- current RGB: 128,0,0
  • group_13 : Group #14 -- current RGB: 0,128,0
  • group_14 : Group #15 -- current RGB: 0,0,128
  • group_15 : Group #16 -- current RGB: 128,128,0
  • group_16 : Group #17 -- current RGB: 128,0,128
  • group_17 : Group #18 -- current RGB: 0,128,128
  • group_18 : Group #19 -- current RGB: 192,128,0
  • group_19 : Group #20 -- current RGB: 0,192,128
  • group_20 : Group #21 -- current RGB: 0,128,192
  • group_21 : Group #22 -- current RGB: 192,128,0
  • group_22 : Group #23 -- current RGB: 128,0,192
  • group_23 : Group #24 -- current RGB: 128,192,0
  • group_24 : Group #25 -- current RGB: 64,0,0
  • group_25 : Group #26 -- current RGB: 0,64,0
  • group_26 : Group #27 -- current RGB: 0,0,64
  • group_27 : Group #28 -- current RGB: 64,64,0
  • group_28 : Group #29 -- current RGB: 64,0,64
  • group_29 : Group #30 -- current RGB: 0,64,64
  • group_30 : Group #31 -- current RGB: 64,0,64
  • group_31 : Group #32 -- current RGB: 0,64,64
  • group_32 : Group #33 -- current RGB: 128,255,255
  • group_33 : Group #34 -- current RGB: 128,0,128
  • group_34 : Group #35 -- current RGB: 1,255,128
  • group_35 : Group #36 -- current RGB: 128,0,255
  • group_36 : Group #37 -- current RGB: 1,255,255
  • group_37 : Group #38 -- current RGB: 1,0,128
  • group_38 : Group #39 -- current RGB: 128,255,224
  • group_39 : Group #40 -- current RGB: 128,63,128
  • group_40 : Group #41 -- current RGB: 32,255,128
  • group_41 : Group #42 -- current RGB: 128,63,224
  • group_42 : Group #43 -- current RGB: 32,255,224
  • group_43 : Group #44 -- current RGB: 32,63,128
  • group_44 : Group #45 -- current RGB: 128,255,192
  • group_45 : Group #46 -- current RGB: 128,127,128
  • group_46 : Group #47 -- current RGB: 64,255,128
  • group_47 : Group #48 -- current RGB: 128,127,192
  • group_48 : Group #49 -- current RGB: 64,255,192
  • group_49 : Group #50 -- current RGB: 64,127,128
  • group_50 : Group #51 -- current RGB: 128,127,224
  • group_51 : Group #52 -- current RGB: 64,63,128
  • group_52 : Group #53 -- current RGB: 32,127,128
  • group_53 : Group #54 -- current RGB: 128,127,224
  • group_54 : Group #55 -- current RGB: 32,255,192
  • group_55 : Group #56 -- current RGB: 128,63,192
  • group_56 : Group #57 -- current RGB: 128,255,160
  • group_57 : Group #58 -- current RGB: 128,191,128
  • group_58 : Group #59 -- current RGB: 96,255,128
  • group_59 : Group #60 -- current RGB: 128,191,160
  • group_60 : Group #61 -- current RGB: 96,255,160
  • group_61 : Group #62 -- current RGB: 96,191,128
  • group_62 : Group #63 -- current RGB: 96,255,160
  • group_63 : Group #64 -- current RGB: 96,191,128
bool SetToggleCommandState(int section_id, int command_id, int state)
bool SetToggleCommandState(int section_id, int command_id, int state)
boolean reaper.SetToggleCommandState(integer section_id, integer command_id, integer state)
Boolean RPR_SetToggleCommandState(Int section_id, Int command_id, Int state)

Updates the toggle state of an action, returns true if succeeded. Only ReaScripts can have their toggle states changed programmatically. See RefreshToolbar2.

void SetTrackAutomationMode(MediaTrack* tr, int mode)
SetTrackAutomationMode(MediaTrack tr, int mode)
reaper.SetTrackAutomationMode(MediaTrack tr, integer mode)
RPR_SetTrackAutomationMode(MediaTrack tr, Int mode)
void SetTrackColor(MediaTrack* track, int color)
SetTrackColor(MediaTrack track, int color)
reaper.SetTrackColor(MediaTrack track, integer color)
RPR_SetTrackColor(MediaTrack track, Int color)

Set the custom track color, color is OS dependent (i.e. ColorToNative(r,g,b). To unset the track color, see SetMediaTrackInfo_Value I_CUSTOMCOLOR

bool SetTrackMIDILyrics(MediaTrack* track, int flag, const char* str)
bool SetTrackMIDILyrics(MediaTrack track, int flag, "str")
boolean reaper.SetTrackMIDILyrics(MediaTrack track, integer flag, string str)
Boolean RPR_SetTrackMIDILyrics(MediaTrack track, Int flag, String str)

Set all MIDI lyrics on the track. Lyrics will be stuffed into any MIDI items found in range. Flag is unused at present. str is passed in as beat position, tab, text, tab (example with flag=2: "1.1.2\tLyric for measure 1 beat 2\t2.1.1\tLyric for measure 2 beat 1 "). See GetTrackMIDILyrics

bool SetTrackMIDINoteName(int track, int pitch, int chan, const char* name)
bool SetTrackMIDINoteName(int track, int pitch, int chan, "name")
boolean reaper.SetTrackMIDINoteName(integer track, integer pitch, integer chan, string name)
Boolean RPR_SetTrackMIDINoteName(Int track, Int pitch, Int chan, String name)

channel < 0 assigns these note names to all channels.

bool SetTrackMIDINoteNameEx(ReaProject* proj, MediaTrack* track, int pitch, int chan, const char* name)
bool SetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, int pitch, int chan, "name")
boolean reaper.SetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, integer pitch, integer chan, string name)
Boolean RPR_SetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, Int pitch, Int chan, String name)

channel < 0 assigns note name to all channels. pitch 128 assigns name for CC0, pitch 129 for CC1, etc.

void SetTrackSelected(MediaTrack* track, bool selected)
SetTrackSelected(MediaTrack track, bool selected)
reaper.SetTrackSelected(MediaTrack track, boolean selected)
RPR_SetTrackSelected(MediaTrack track, Boolean selected)
bool SetTrackSendInfo_Value(MediaTrack* tr, int category, int sendidx, const char* parmname, double newvalue)
bool SetTrackSendInfo_Value(MediaTrack tr, int category, int sendidx, "parmname", newvalue)
boolean reaper.SetTrackSendInfo_Value(MediaTrack tr, integer category, integer sendidx, string parmname, number newvalue)
Boolean RPR_SetTrackSendInfo_Value(MediaTrack tr, Int category, Int sendidx, String parmname, Float newvalue)

Set send/receive/hardware output numerical-value attributes, return true on success.
category is <0 for receives, 0=sends, >0 for hardware outputs
parameter names:
B_MUTE : bool *
B_PHASE : bool * : true to flip phase
B_MONO : bool *
D_VOL : double * : 1.0 = +0dB etc
D_PAN : double * : -1..+1
D_PANLAW : double * : 1.0=+0.0db, 0.5=-6dB, -1.0 = projdef etc
I_SENDMODE : int * : 0=post-fader, 1=pre-fx, 2=post-fx (deprecated), 3=post-fx
I_AUTOMODE : int * : automation mode (-1=use track automode, 0=trim/off, 1=read, 2=touch, 3=write, 4=latch)
I_SRCCHAN : int * : -1 for no audio send. Low 10 bits specify channel offset, and higher bits specify channel count. (srcchan>>10) == 0 for stereo, 1 for mono, 2 for 4 channel, 3 for 6 channel, etc.
I_DSTCHAN : int * : low 10 bits are destination index, &1024 set to mix to mono.
I_MIDIFLAGS : int * : low 5 bits=source channel 0=all, 1-16, 31=MIDI send disabled, next 5 bits=dest channel, 0=orig, 1-16=chan. &1024 for faders-send MIDI vol/pan. (>>14)&255 = src bus (0 for all, 1 for normal, 2+). (>>22)&255=destination bus (0 for all, 1 for normal, 2+)
See CreateTrackSend, RemoveTrackSend, GetTrackNumSends.

bool SetTrackSendUIPan(MediaTrack* track, int send_idx, double pan, int isend)
bool SetTrackSendUIPan(MediaTrack track, int send_idx, pan, int isend)
boolean reaper.SetTrackSendUIPan(MediaTrack track, integer send_idx, number pan, integer isend)
Boolean RPR_SetTrackSendUIPan(MediaTrack track, Int send_idx, Float pan, Int isend)

send_idx<0 for receives, >=0 for hw ouputs, >=nb_of_hw_ouputs for sends. isend=1 for end of edit, -1 for an instant edit (such as reset), 0 for normal tweak.

bool SetTrackSendUIVol(MediaTrack* track, int send_idx, double vol, int isend)
bool SetTrackSendUIVol(MediaTrack track, int send_idx, vol, int isend)
boolean reaper.SetTrackSendUIVol(MediaTrack track, integer send_idx, number vol, integer isend)
Boolean RPR_SetTrackSendUIVol(MediaTrack track, Int send_idx, Float vol, Int isend)

send_idx<0 for receives, >=0 for hw ouputs, >=nb_of_hw_ouputs for sends. isend=1 for end of edit, -1 for an instant edit (such as reset), 0 for normal tweak.

bool SetTrackStateChunk(MediaTrack* track, const char* str, bool isundoOptional)
bool SetTrackStateChunk(MediaTrack track, "str", bool isundo)
boolean reaper.SetTrackStateChunk(MediaTrack track, string str, boolean isundo)
Boolean RPR_SetTrackStateChunk(MediaTrack track, String str, Boolean isundoOptional)

Sets the RPPXML state of a track, returns true if successful. Undo flag is a performance/caching hint.

int SetTrackUIInputMonitor(MediaTrack* track, int monitor, int igngroupflags)
int SetTrackUIInputMonitor(MediaTrack track, int monitor, int igngroupflags)
integer reaper.SetTrackUIInputMonitor(MediaTrack track, integer monitor, integer igngroupflags)
Int RPR_SetTrackUIInputMonitor(MediaTrack track, Int monitor, Int igngroupflags)

monitor: 0=no monitoring, 1=monitoring, 2=auto-monitoring. returns new value or -1 if error. igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging

int SetTrackUIMute(MediaTrack* track, int mute, int igngroupflags)
int SetTrackUIMute(MediaTrack track, int mute, int igngroupflags)
integer reaper.SetTrackUIMute(MediaTrack track, integer mute, integer igngroupflags)
Int RPR_SetTrackUIMute(MediaTrack track, Int mute, Int igngroupflags)

mute: <0 toggles, >0 sets mute, 0=unsets mute. returns new value or -1 if error. igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging

double SetTrackUIPan(MediaTrack* track, double pan, bool relative, bool done, int igngroupflags)
double SetTrackUIPan(MediaTrack track, pan, bool relative, bool done, int igngroupflags)
number reaper.SetTrackUIPan(MediaTrack track, number pan, boolean relative, boolean done, integer igngroupflags)
Float RPR_SetTrackUIPan(MediaTrack track, Float pan, Boolean relative, Boolean done, Int igngroupflags)

igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging

int SetTrackUIPolarity(MediaTrack* track, int polarity, int igngroupflags)
int SetTrackUIPolarity(MediaTrack track, int polarity, int igngroupflags)
integer reaper.SetTrackUIPolarity(MediaTrack track, integer polarity, integer igngroupflags)
Int RPR_SetTrackUIPolarity(MediaTrack track, Int polarity, Int igngroupflags)

polarity (AKA phase): <0 toggles, 0=normal, >0=inverted. returns new value or -1 if error.igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging

int SetTrackUIRecArm(MediaTrack* track, int recarm, int igngroupflags)
int SetTrackUIRecArm(MediaTrack track, int recarm, int igngroupflags)
integer reaper.SetTrackUIRecArm(MediaTrack track, integer recarm, integer igngroupflags)
Int RPR_SetTrackUIRecArm(MediaTrack track, Int recarm, Int igngroupflags)

recarm: <0 toggles, >0 sets recarm, 0=unsets recarm. returns new value or -1 if error. igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging

int SetTrackUISolo(MediaTrack* track, int solo, int igngroupflags)
int SetTrackUISolo(MediaTrack track, int solo, int igngroupflags)
integer reaper.SetTrackUISolo(MediaTrack track, integer solo, integer igngroupflags)
Int RPR_SetTrackUISolo(MediaTrack track, Int solo, Int igngroupflags)

solo: <0 toggles, 1 sets solo (default mode), 0=unsets solo, 2 sets solo (non-SIP), 4 sets solo (SIP). returns new value or -1 if error. igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging

double SetTrackUIVolume(MediaTrack* track, double volume, bool relative, bool done, int igngroupflags)
double SetTrackUIVolume(MediaTrack track, volume, bool relative, bool done, int igngroupflags)
number reaper.SetTrackUIVolume(MediaTrack track, number volume, boolean relative, boolean done, integer igngroupflags)
Float RPR_SetTrackUIVolume(MediaTrack track, Float volume, Boolean relative, Boolean done, Int igngroupflags)

igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging

double SetTrackUIWidth(MediaTrack* track, double width, bool relative, bool done, int igngroupflags)
double SetTrackUIWidth(MediaTrack track, width, bool relative, bool done, int igngroupflags)
number reaper.SetTrackUIWidth(MediaTrack track, number width, boolean relative, boolean done, integer igngroupflags)
Float RPR_SetTrackUIWidth(MediaTrack track, Float width, Boolean relative, Boolean done, Int igngroupflags)

igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging

void ShowActionList(KbdSectionInfo* section, HWND callerWnd)
ShowActionList(KbdSectionInfo section, HWND callerWnd)
reaper.ShowActionList(KbdSectionInfo section, HWND callerWnd)
RPR_ShowActionList(KbdSectionInfo section, HWND callerWnd)
void ShowConsoleMsg(const char* msg)
ShowConsoleMsg("msg")
reaper.ShowConsoleMsg(string msg)
RPR_ShowConsoleMsg(String msg)

Show a message to the user (also useful for debugging). Send "\n" for newline, "" to clear the console. Prefix string with "!SHOW:" and text will be added to console without opening the window. See ClearConsole

int ShowMessageBox(const char* msg, const char* title, int type)
int ShowMessageBox("msg", "title", int type)
integer reaper.ShowMessageBox(string msg, string title, integer type)
Int RPR_ShowMessageBox(String msg, String title, Int type)

type 0=OK,1=OKCANCEL,2=ABORTRETRYIGNORE,3=YESNOCANCEL,4=YESNO,5=RETRYCANCEL : ret 1=OK,2=CANCEL,3=ABORT,4=RETRY,5=IGNORE,6=YES,7=NO

void ShowPopupMenu(const char* name, int x, int y, HWND hwndParentOptional, void* ctxOptional, int ctx2Optional, int ctx3Optional)
ShowPopupMenu("name", int x, int y, HWND hwndParent, void* ctx, int ctx2, int ctx3)
reaper.ShowPopupMenu(string name, integer x, integer y, HWND hwndParent, identifier ctx, integer ctx2, integer ctx3)
RPR_ShowPopupMenu(String name, Int x, Int y, HWND hwndParentOptional, void ctxOptional, Int ctx2Optional, Int ctx3Optional)

shows a context menu, valid names include: track_input, track_panel, track_area, track_routing, item, ruler, envelope, envelope_point, envelope_item. ctxOptional can be a track pointer for track_*, item pointer for item* (but is optional). for envelope_point, ctx2Optional has point index, ctx3Optional has item index (0=main envelope, 1=first AI). for envelope_item, ctx2Optional has AI index (1=first AI)

double SLIDER2DB(double y)
double SLIDER2DB(y)
number reaper.SLIDER2DB(number y)
Float RPR_SLIDER2DB(Float y)
double SnapToGrid(ReaProject* project, double time_pos)
double SnapToGrid(ReaProject project, time_pos)
number reaper.SnapToGrid(ReaProject project, number time_pos)
Float RPR_SnapToGrid(ReaProject project, Float time_pos)
void SoloAllTracks(int solo)
SoloAllTracks(int solo)
reaper.SoloAllTracks(integer solo)
RPR_SoloAllTracks(Int solo)

solo=2 for SIP

HWND Splash_GetWnd()
HWND Splash_GetWnd()
HWND reaper.Splash_GetWnd()
HWND RPR_Splash_GetWnd()

gets the splash window, in case you want to display a message over it. Returns NULL when the splash window is not displayed.

MediaItem* SplitMediaItem(MediaItem* item, double position)
MediaItem SplitMediaItem(MediaItem item, position)
MediaItem reaper.SplitMediaItem(MediaItem item, number position)
MediaItem RPR_SplitMediaItem(MediaItem item, Float position)

the original item becomes the left-hand split, the function returns the right-hand split (or NULL if the split failed)

void stringToGuid(const char* str, GUID* g)
stringToGuid("str", #gGUID)
string gGUID = reaper.stringToGuid(string str, string gGUID)
RPR_stringToGuid(String str, GUID g)
void StuffMIDIMessage(int mode, int msg1, int msg2, int msg3)
StuffMIDIMessage(int mode, int msg1, int msg2, int msg3)
reaper.StuffMIDIMessage(integer mode, integer msg1, integer msg2, integer msg3)
RPR_StuffMIDIMessage(Int mode, Int msg1, Int msg2, Int msg3)

Stuffs a 3 byte MIDI message into either the Virtual MIDI Keyboard queue, or the MIDI-as-control input queue, or sends to a MIDI hardware output. mode=0 for VKB, 1 for control (actions map etc), 2 for VKB-on-current-channel; 16 for external MIDI device 0, 17 for external MIDI device 1, etc; see GetNumMIDIOutputs, GetMIDIOutputName.

int TakeFX_AddByName(MediaItem_Take* take, const char* fxname, int instantiate)
int TakeFX_AddByName(MediaItem_Take take, "fxname", int instantiate)
integer reaper.TakeFX_AddByName(MediaItem_Take take, string fxname, integer instantiate)
Int RPR_TakeFX_AddByName(MediaItem_Take take, String fxname, Int instantiate)

Adds or queries the position of a named FX in a take. See TrackFX_AddByName() for information on fxname and instantiate. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TakeFX_CopyToTake(MediaItem_Take* src_take, int src_fx, MediaItem_Take* dest_take, int dest_fx, bool is_move)
TakeFX_CopyToTake(MediaItem_Take src_take, int src_fx, MediaItem_Take dest_take, int dest_fx, bool is_move)
reaper.TakeFX_CopyToTake(MediaItem_Take src_take, integer src_fx, MediaItem_Take dest_take, integer dest_fx, boolean is_move)
RPR_TakeFX_CopyToTake(MediaItem_Take src_take, Int src_fx, MediaItem_Take dest_take, Int dest_fx, Boolean is_move)

Copies (or moves) FX from src_take to dest_take. Can be used with src_take=dest_take to reorder. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TakeFX_CopyToTrack(MediaItem_Take* src_take, int src_fx, MediaTrack* dest_track, int dest_fx, bool is_move)
TakeFX_CopyToTrack(MediaItem_Take src_take, int src_fx, MediaTrack dest_track, int dest_fx, bool is_move)
reaper.TakeFX_CopyToTrack(MediaItem_Take src_take, integer src_fx, MediaTrack dest_track, integer dest_fx, boolean is_move)
RPR_TakeFX_CopyToTrack(MediaItem_Take src_take, Int src_fx, MediaTrack dest_track, Int dest_fx, Boolean is_move)

Copies (or moves) FX from src_take to dest_track. dest_fx can have 0x1000000 set to reference input FX. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_Delete(MediaItem_Take* take, int fx)
bool TakeFX_Delete(MediaItem_Take take, int fx)
boolean reaper.TakeFX_Delete(MediaItem_Take take, integer fx)
Boolean RPR_TakeFX_Delete(MediaItem_Take take, Int fx)

Remove a FX from take chain (returns true on success) FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_EndParamEdit(MediaItem_Take* take, int fx, int param)
bool TakeFX_EndParamEdit(MediaItem_Take take, int fx, int param)
boolean reaper.TakeFX_EndParamEdit(MediaItem_Take take, integer fx, integer param)
Boolean RPR_TakeFX_EndParamEdit(MediaItem_Take take, Int fx, Int param)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_FormatParamValue(MediaItem_Take* take, int fx, int param, double val, char* bufOut, int bufOut_sz)
bool TakeFX_FormatParamValue(MediaItem_Take take, int fx, int param, val, #buf)
boolean retval, string buf = reaper.TakeFX_FormatParamValue(MediaItem_Take take, integer fx, integer param, number val)
(Boolean retval, MediaItem_Take take, Int fx, Int param, Float val, String bufOut, Int bufOut_sz) = RPR_TakeFX_FormatParamValue(take, fx, param, val, bufOut, bufOut_sz)

Note: only works with FX that support Cockos VST extensions. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_FormatParamValueNormalized(MediaItem_Take* take, int fx, int param, double value, char* buf, int buf_sz)
bool TakeFX_FormatParamValueNormalized(MediaItem_Take take, int fx, int param, value, #buf)
boolean retval, string buf = reaper.TakeFX_FormatParamValueNormalized(MediaItem_Take take, integer fx, integer param, number value, string buf)
(Boolean retval, MediaItem_Take take, Int fx, Int param, Float value, String buf, Int buf_sz) = RPR_TakeFX_FormatParamValueNormalized(take, fx, param, value, buf, buf_sz)

Note: only works with FX that support Cockos VST extensions. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TakeFX_GetChainVisible(MediaItem_Take* take)
int TakeFX_GetChainVisible(MediaItem_Take take)
integer reaper.TakeFX_GetChainVisible(MediaItem_Take take)
Int RPR_TakeFX_GetChainVisible(MediaItem_Take take)

returns index of effect visible in chain, or -1 for chain hidden, or -2 for chain visible but no effect selected

int TakeFX_GetCount(MediaItem_Take* take)
int TakeFX_GetCount(MediaItem_Take take)
integer reaper.TakeFX_GetCount(MediaItem_Take take)
Int RPR_TakeFX_GetCount(MediaItem_Take take)
bool TakeFX_GetEnabled(MediaItem_Take* take, int fx)
bool TakeFX_GetEnabled(MediaItem_Take take, int fx)
boolean reaper.TakeFX_GetEnabled(MediaItem_Take take, integer fx)
Boolean RPR_TakeFX_GetEnabled(MediaItem_Take take, Int fx)

See TakeFX_SetEnabled FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

TrackEnvelope* TakeFX_GetEnvelope(MediaItem_Take* take, int fxindex, int parameterindex, bool create)
TrackEnvelope TakeFX_GetEnvelope(MediaItem_Take take, int fxindex, int parameterindex, bool create)
TrackEnvelope reaper.TakeFX_GetEnvelope(MediaItem_Take take, integer fxindex, integer parameterindex, boolean create)
TrackEnvelope RPR_TakeFX_GetEnvelope(MediaItem_Take take, Int fxindex, Int parameterindex, Boolean create)

Returns the FX parameter envelope. If the envelope does not exist and create=true, the envelope will be created. If the envelope already exists and is bypassed and create=true, then the envelope will be unbypassed. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

HWND TakeFX_GetFloatingWindow(MediaItem_Take* take, int index)
HWND TakeFX_GetFloatingWindow(MediaItem_Take take, int index)
HWND reaper.TakeFX_GetFloatingWindow(MediaItem_Take take, integer index)
HWND RPR_TakeFX_GetFloatingWindow(MediaItem_Take take, Int index)

returns HWND of floating window for effect index, if any FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_GetFormattedParamValue(MediaItem_Take* take, int fx, int param, char* bufOut, int bufOut_sz)
bool TakeFX_GetFormattedParamValue(MediaItem_Take take, int fx, int param, #buf)
boolean retval, string buf = reaper.TakeFX_GetFormattedParamValue(MediaItem_Take take, integer fx, integer param)
(Boolean retval, MediaItem_Take take, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TakeFX_GetFormattedParamValue(take, fx, param, bufOut, bufOut_sz)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

GUID* TakeFX_GetFXGUID(MediaItem_Take* take, int fx)
bool TakeFX_GetFXGUID(#retguid, MediaItem_Take take, int fx)
string GUID = reaper.TakeFX_GetFXGUID(MediaItem_Take take, integer fx)
GUID RPR_TakeFX_GetFXGUID(MediaItem_Take take, Int fx)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_GetFXName(MediaItem_Take* take, int fx, char* bufOut, int bufOut_sz)
bool TakeFX_GetFXName(MediaItem_Take take, int fx, #buf)
boolean retval, string buf = reaper.TakeFX_GetFXName(MediaItem_Take take, integer fx)
(Boolean retval, MediaItem_Take take, Int fx, String bufOut, Int bufOut_sz) = RPR_TakeFX_GetFXName(take, fx, bufOut, bufOut_sz)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TakeFX_GetIOSize(MediaItem_Take* take, int fx, int* inputPinsOut, int* outputPinsOut)
int TakeFX_GetIOSize(MediaItem_Take take, int fx, int &inputPins, int &outputPins)
integer retval, integer inputPins, integer outputPins = reaper.TakeFX_GetIOSize(MediaItem_Take take, integer fx)
(Int retval, MediaItem_Take take, Int fx, Int inputPinsOut, Int outputPinsOut) = RPR_TakeFX_GetIOSize(take, fx, inputPinsOut, outputPinsOut)

Gets the number of input/output pins for FX if available, returns plug-in type or -1 on error FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_GetNamedConfigParm(MediaItem_Take* take, int fx, const char* parmname, char* bufOutNeedBig, int bufOutNeedBig_sz)
bool TakeFX_GetNamedConfigParm(MediaItem_Take take, int fx, "parmname", #buf)
boolean retval, string buf = reaper.TakeFX_GetNamedConfigParm(MediaItem_Take take, integer fx, string parmname)
(Boolean retval, MediaItem_Take take, Int fx, String parmname, String bufOutNeedBig, Int bufOutNeedBig_sz) = RPR_TakeFX_GetNamedConfigParm(take, fx, parmname, bufOutNeedBig, bufOutNeedBig_sz)

gets plug-in specific named configuration value (returns true on success). see TrackFX_GetNamedConfigParm FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TakeFX_GetNumParams(MediaItem_Take* take, int fx)
int TakeFX_GetNumParams(MediaItem_Take take, int fx)
integer reaper.TakeFX_GetNumParams(MediaItem_Take take, integer fx)
Int RPR_TakeFX_GetNumParams(MediaItem_Take take, Int fx)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_GetOffline(MediaItem_Take* take, int fx)
bool TakeFX_GetOffline(MediaItem_Take take, int fx)
boolean reaper.TakeFX_GetOffline(MediaItem_Take take, integer fx)
Boolean RPR_TakeFX_GetOffline(MediaItem_Take take, Int fx)

See TakeFX_SetOffline FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_GetOpen(MediaItem_Take* take, int fx)
bool TakeFX_GetOpen(MediaItem_Take take, int fx)
boolean reaper.TakeFX_GetOpen(MediaItem_Take take, integer fx)
Boolean RPR_TakeFX_GetOpen(MediaItem_Take take, Int fx)

Returns true if this FX UI is open in the FX chain window or a floating window. See TakeFX_SetOpen FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

double TakeFX_GetParam(MediaItem_Take* take, int fx, int param, double* minvalOut, double* maxvalOut)
double TakeFX_GetParam(MediaItem_Take take, int fx, int param, &minval, &maxval)
number retval, number minval, number maxval = reaper.TakeFX_GetParam(MediaItem_Take take, integer fx, integer param)
(Float retval, MediaItem_Take take, Int fx, Int param, Float minvalOut, Float maxvalOut) = RPR_TakeFX_GetParam(take, fx, param, minvalOut, maxvalOut)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_GetParameterStepSizes(MediaItem_Take* take, int fx, int param, double* stepOut, double* smallstepOut, double* largestepOut, bool* istoggleOut)
bool TakeFX_GetParameterStepSizes(MediaItem_Take take, int fx, int param, &step, &smallstep, &largestep, bool &istoggle)
boolean retval, number step, number smallstep, number largestep, boolean istoggle = reaper.TakeFX_GetParameterStepSizes(MediaItem_Take take, integer fx, integer param)
(Boolean retval, MediaItem_Take take, Int fx, Int param, Float stepOut, Float smallstepOut, Float largestepOut, Boolean istoggleOut) = RPR_TakeFX_GetParameterStepSizes(take, fx, param, stepOut, smallstepOut, largestepOut, istoggleOut)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

double TakeFX_GetParamEx(MediaItem_Take* take, int fx, int param, double* minvalOut, double* maxvalOut, double* midvalOut)
double TakeFX_GetParamEx(MediaItem_Take take, int fx, int param, &minval, &maxval, &midval)
number retval, number minval, number maxval, number midval = reaper.TakeFX_GetParamEx(MediaItem_Take take, integer fx, integer param)
(Float retval, MediaItem_Take take, Int fx, Int param, Float minvalOut, Float maxvalOut, Float midvalOut) = RPR_TakeFX_GetParamEx(take, fx, param, minvalOut, maxvalOut, midvalOut)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TakeFX_GetParamFromIdent(MediaItem_Take* take, int fx, const char* ident_str)
int TakeFX_GetParamFromIdent(MediaItem_Take take, int fx, "ident_str")
integer reaper.TakeFX_GetParamFromIdent(MediaItem_Take take, integer fx, string ident_str)
Int RPR_TakeFX_GetParamFromIdent(MediaItem_Take take, Int fx, String ident_str)

gets the parameter index from an identifying string (:wet, :bypass, or a string returned from GetParamIdent), or -1 if unknown. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_GetParamIdent(MediaItem_Take* take, int fx, int param, char* bufOut, int bufOut_sz)
bool TakeFX_GetParamIdent(MediaItem_Take take, int fx, int param, #buf)
boolean retval, string buf = reaper.TakeFX_GetParamIdent(MediaItem_Take take, integer fx, integer param)
(Boolean retval, MediaItem_Take take, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TakeFX_GetParamIdent(take, fx, param, bufOut, bufOut_sz)

gets an identifying string for the parameter FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_GetParamName(MediaItem_Take* take, int fx, int param, char* bufOut, int bufOut_sz)
bool TakeFX_GetParamName(MediaItem_Take take, int fx, int param, #buf)
boolean retval, string buf = reaper.TakeFX_GetParamName(MediaItem_Take take, integer fx, integer param)
(Boolean retval, MediaItem_Take take, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TakeFX_GetParamName(take, fx, param, bufOut, bufOut_sz)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

double TakeFX_GetParamNormalized(MediaItem_Take* take, int fx, int param)
double TakeFX_GetParamNormalized(MediaItem_Take take, int fx, int param)
number reaper.TakeFX_GetParamNormalized(MediaItem_Take take, integer fx, integer param)
Float RPR_TakeFX_GetParamNormalized(MediaItem_Take take, Int fx, Int param)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TakeFX_GetPinMappings(MediaItem_Take* take, int fx, int isoutput, int pin, int* high32Out)
int TakeFX_GetPinMappings(MediaItem_Take take, int fx, int isoutput, int pin, int &high32)
integer retval, integer high32 = reaper.TakeFX_GetPinMappings(MediaItem_Take take, integer fx, integer isoutput, integer pin)
(Int retval, MediaItem_Take take, Int fx, Int isoutput, Int pin, Int high32Out) = RPR_TakeFX_GetPinMappings(take, fx, isoutput, pin, high32Out)

gets the effective channel mapping bitmask for a particular pin. high32Out will be set to the high 32 bits. Add 0x1000000 to pin index in order to access the second 64 bits of mappings independent of the first 64 bits. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_GetPreset(MediaItem_Take* take, int fx, char* presetnameOut, int presetnameOut_sz)
bool TakeFX_GetPreset(MediaItem_Take take, int fx, #presetname)
boolean retval, string presetname = reaper.TakeFX_GetPreset(MediaItem_Take take, integer fx)
(Boolean retval, MediaItem_Take take, Int fx, String presetnameOut, Int presetnameOut_sz) = RPR_TakeFX_GetPreset(take, fx, presetnameOut, presetnameOut_sz)

Get the name of the preset currently showing in the REAPER dropdown, or the full path to a factory preset file for VST3 plug-ins (.vstpreset). See TakeFX_SetPreset. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TakeFX_GetPresetIndex(MediaItem_Take* take, int fx, int* numberOfPresetsOut)
int TakeFX_GetPresetIndex(MediaItem_Take take, int fx, int &numberOfPresets)
integer retval, integer numberOfPresets = reaper.TakeFX_GetPresetIndex(MediaItem_Take take, integer fx)
(Int retval, MediaItem_Take take, Int fx, Int numberOfPresetsOut) = RPR_TakeFX_GetPresetIndex(take, fx, numberOfPresetsOut)

Returns current preset index, or -1 if error. numberOfPresetsOut will be set to total number of presets available. See TakeFX_SetPresetByIndex FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TakeFX_GetUserPresetFilename(MediaItem_Take* take, int fx, char* fnOut, int fnOut_sz)
TakeFX_GetUserPresetFilename(MediaItem_Take take, int fx, #fn)
string fn = reaper.TakeFX_GetUserPresetFilename(MediaItem_Take take, integer fx)
(MediaItem_Take take, Int fx, String fnOut, Int fnOut_sz) = RPR_TakeFX_GetUserPresetFilename(take, fx, fnOut, fnOut_sz)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_NavigatePresets(MediaItem_Take* take, int fx, int presetmove)
bool TakeFX_NavigatePresets(MediaItem_Take take, int fx, int presetmove)
boolean reaper.TakeFX_NavigatePresets(MediaItem_Take take, integer fx, integer presetmove)
Boolean RPR_TakeFX_NavigatePresets(MediaItem_Take take, Int fx, Int presetmove)

presetmove==1 activates the next preset, presetmove==-1 activates the previous preset, etc. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TakeFX_SetEnabled(MediaItem_Take* take, int fx, bool enabled)
TakeFX_SetEnabled(MediaItem_Take take, int fx, bool enabled)
reaper.TakeFX_SetEnabled(MediaItem_Take take, integer fx, boolean enabled)
RPR_TakeFX_SetEnabled(MediaItem_Take take, Int fx, Boolean enabled)

See TakeFX_GetEnabled FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_SetNamedConfigParm(MediaItem_Take* take, int fx, const char* parmname, const char* value)
bool TakeFX_SetNamedConfigParm(MediaItem_Take take, int fx, "parmname", "value")
boolean reaper.TakeFX_SetNamedConfigParm(MediaItem_Take take, integer fx, string parmname, string value)
Boolean RPR_TakeFX_SetNamedConfigParm(MediaItem_Take take, Int fx, String parmname, String value)

gets plug-in specific named configuration value (returns true on success). see TrackFX_SetNamedConfigParm FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TakeFX_SetOffline(MediaItem_Take* take, int fx, bool offline)
TakeFX_SetOffline(MediaItem_Take take, int fx, bool offline)
reaper.TakeFX_SetOffline(MediaItem_Take take, integer fx, boolean offline)
RPR_TakeFX_SetOffline(MediaItem_Take take, Int fx, Boolean offline)

See TakeFX_GetOffline FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TakeFX_SetOpen(MediaItem_Take* take, int fx, bool open)
TakeFX_SetOpen(MediaItem_Take take, int fx, bool open)
reaper.TakeFX_SetOpen(MediaItem_Take take, integer fx, boolean open)
RPR_TakeFX_SetOpen(MediaItem_Take take, Int fx, Boolean open)

Open this FX UI. See TakeFX_GetOpen FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_SetParam(MediaItem_Take* take, int fx, int param, double val)
bool TakeFX_SetParam(MediaItem_Take take, int fx, int param, val)
boolean reaper.TakeFX_SetParam(MediaItem_Take take, integer fx, integer param, number val)
Boolean RPR_TakeFX_SetParam(MediaItem_Take take, Int fx, Int param, Float val)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_SetParamNormalized(MediaItem_Take* take, int fx, int param, double value)
bool TakeFX_SetParamNormalized(MediaItem_Take take, int fx, int param, value)
boolean reaper.TakeFX_SetParamNormalized(MediaItem_Take take, integer fx, integer param, number value)
Boolean RPR_TakeFX_SetParamNormalized(MediaItem_Take take, Int fx, Int param, Float value)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_SetPinMappings(MediaItem_Take* take, int fx, int isoutput, int pin, int low32bits, int hi32bits)
bool TakeFX_SetPinMappings(MediaItem_Take take, int fx, int isoutput, int pin, int low32bits, int hi32bits)
boolean reaper.TakeFX_SetPinMappings(MediaItem_Take take, integer fx, integer isoutput, integer pin, integer low32bits, integer hi32bits)
Boolean RPR_TakeFX_SetPinMappings(MediaItem_Take take, Int fx, Int isoutput, Int pin, Int low32bits, Int hi32bits)

sets the channel mapping bitmask for a particular pin. returns false if unsupported (not all types of plug-ins support this capability). Add 0x1000000 to pin index in order to access the second 64 bits of mappings independent of the first 64 bits. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_SetPreset(MediaItem_Take* take, int fx, const char* presetname)
bool TakeFX_SetPreset(MediaItem_Take take, int fx, "presetname")
boolean reaper.TakeFX_SetPreset(MediaItem_Take take, integer fx, string presetname)
Boolean RPR_TakeFX_SetPreset(MediaItem_Take take, Int fx, String presetname)

Activate a preset with the name shown in the REAPER dropdown. Full paths to .vstpreset files are also supported for VST3 plug-ins. See TakeFX_GetPreset. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeFX_SetPresetByIndex(MediaItem_Take* take, int fx, int idx)
bool TakeFX_SetPresetByIndex(MediaItem_Take take, int fx, int idx)
boolean reaper.TakeFX_SetPresetByIndex(MediaItem_Take take, integer fx, integer idx)
Boolean RPR_TakeFX_SetPresetByIndex(MediaItem_Take take, Int fx, Int idx)

Sets the preset idx, or the factory preset (idx==-2), or the default user preset (idx==-1). Returns true on success. See TakeFX_GetPresetIndex. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TakeFX_Show(MediaItem_Take* take, int index, int showFlag)
TakeFX_Show(MediaItem_Take take, int index, int showFlag)
reaper.TakeFX_Show(MediaItem_Take take, integer index, integer showFlag)
RPR_TakeFX_Show(MediaItem_Take take, Int index, Int showFlag)

showflag=0 for hidechain, =1 for show chain(index valid), =2 for hide floating window(index valid), =3 for show floating window (index valid) FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TakeIsMIDI(MediaItem_Take* take)
bool TakeIsMIDI(MediaItem_Take take)
boolean reaper.TakeIsMIDI(MediaItem_Take take)
Boolean RPR_TakeIsMIDI(MediaItem_Take take)

Returns true if the active take contains MIDI.

bool ThemeLayout_GetLayout(const char* section, int idx, char* nameOut, int nameOut_sz)
bool ThemeLayout_GetLayout("section", int idx, #name)
boolean retval, string name = reaper.ThemeLayout_GetLayout(string section, integer idx)
(Boolean retval, String section, Int idx, String nameOut, Int nameOut_sz) = RPR_ThemeLayout_GetLayout(section, idx, nameOut, nameOut_sz)

Gets theme layout information. section can be 'global' for global layout override, 'seclist' to enumerate a list of layout sections, otherwise a layout section such as 'mcp', 'tcp', 'trans', etc. idx can be -1 to query the current value, -2 to get the description of the section (if not global), -3 will return the current context DPI-scaling (256=normal, 512=retina, etc), or 0..x. returns false if failed.

const char* ThemeLayout_GetParameter(int wp, const char** descOutOptional, int* valueOutOptional, int* defValueOutOptional, int* minValueOutOptional, int* maxValueOutOptional)
bool ThemeLayout_GetParameter(#retval, int wp, optional #desc, optional int &value, optional int &defValue, optional int &minValue, optional int &maxValue)
string retval, optional string desc, optional integer value, optional integer defValue, optional integer minValue, optional integer maxValue = reaper.ThemeLayout_GetParameter(integer wp)
(String retval, Int wp, String descOutOptional, Int valueOutOptional, Int defValueOutOptional, Int minValueOutOptional, Int maxValueOutOptional) = RPR_ThemeLayout_GetParameter(wp, descOutOptional, valueOutOptional, defValueOutOptional, minValueOutOptional, maxValueOutOptional)

returns theme layout parameter. return value is cfg-name, or nil/empty if out of range.

void ThemeLayout_RefreshAll()
ThemeLayout_RefreshAll()
reaper.ThemeLayout_RefreshAll()
RPR_ThemeLayout_RefreshAll()

Refreshes all layouts

bool ThemeLayout_SetLayout(const char* section, const char* layout)
bool ThemeLayout_SetLayout("section", " layout")
boolean reaper.ThemeLayout_SetLayout(string section, string layout)
Boolean RPR_ThemeLayout_SetLayout(String section, String layout)

Sets theme layout override for a particular section -- section can be 'global' or 'mcp' etc. If setting global layout, prefix a ! to the layout string to clear any per-layout overrides. Returns false if failed.

bool ThemeLayout_SetParameter(int wp, int value, bool persist)
bool ThemeLayout_SetParameter(int wp, int value, bool persist)
boolean reaper.ThemeLayout_SetParameter(integer wp, integer value, boolean persist)
Boolean RPR_ThemeLayout_SetParameter(Int wp, Int value, Boolean persist)

sets theme layout parameter to value. persist=true in order to have change loaded on next theme load. note that the caller should update layouts via ??? to make changes visible.

double time_precise()
number reaper.time_precise()
Float RPR_time_precise()

Gets a precise system timestamp in seconds

double TimeMap2_beatsToTime(ReaProject* proj, double tpos, const int* measuresInOptional)
double TimeMap2_beatsToTime(ReaProject proj, tpos, optional int measuresIn)
number reaper.TimeMap2_beatsToTime(ReaProject proj, number tpos, optional integer measuresIn)
Float RPR_TimeMap2_beatsToTime(ReaProject proj, Float tpos, const int measuresInOptional)

convert a beat position (or optionally a beats+measures if measures is non-NULL) to time.

double TimeMap2_GetDividedBpmAtTime(ReaProject* proj, double time)
double TimeMap2_GetDividedBpmAtTime(ReaProject proj, time)
number reaper.TimeMap2_GetDividedBpmAtTime(ReaProject proj, number time)
Float RPR_TimeMap2_GetDividedBpmAtTime(ReaProject proj, Float time)

get the effective BPM at the time (seconds) position (i.e. 2x in /8 signatures)

double TimeMap2_GetNextChangeTime(ReaProject* proj, double time)
double TimeMap2_GetNextChangeTime(ReaProject proj, time)
number reaper.TimeMap2_GetNextChangeTime(ReaProject proj, number time)
Float RPR_TimeMap2_GetNextChangeTime(ReaProject proj, Float time)

when does the next time map (tempo or time sig) change occur

double TimeMap2_QNToTime(ReaProject* proj, double qn)
double TimeMap2_QNToTime(ReaProject proj, qn)
number reaper.TimeMap2_QNToTime(ReaProject proj, number qn)
Float RPR_TimeMap2_QNToTime(ReaProject proj, Float qn)

converts project QN position to time.

double TimeMap2_timeToBeats(ReaProject* proj, double tpos, int* measuresOutOptional, int* cmlOutOptional, double* fullbeatsOutOptional, int* cdenomOutOptional)
double TimeMap2_timeToBeats(ReaProject proj, tpos, optional int &measures, optional int &cml, optional &fullbeats, optional int &cdenom)
number retval, optional integer measures, optional integer cml, optional number fullbeats, optional integer cdenom = reaper.TimeMap2_timeToBeats(ReaProject proj, number tpos)
(Float retval, ReaProject proj, Float tpos, Int measuresOutOptional, Int cmlOutOptional, Float fullbeatsOutOptional, Int cdenomOutOptional) = RPR_TimeMap2_timeToBeats(proj, tpos, measuresOutOptional, cmlOutOptional, fullbeatsOutOptional, cdenomOutOptional)

convert a time into beats.
if measures is non-NULL, measures will be set to the measure count, return value will be beats since measure.
if cml is non-NULL, will be set to current measure length in beats (i.e. time signature numerator)
if fullbeats is non-NULL, and measures is non-NULL, fullbeats will get the full beat count (same value returned if measures is NULL).
if cdenom is non-NULL, will be set to the current time signature denominator.

double TimeMap2_timeToQN(ReaProject* proj, double tpos)
double TimeMap2_timeToQN(ReaProject proj, tpos)
number reaper.TimeMap2_timeToQN(ReaProject proj, number tpos)
Float RPR_TimeMap2_timeToQN(ReaProject proj, Float tpos)

converts project time position to QN position.

double TimeMap_curFrameRate(ReaProject* proj, bool* dropFrameOut)
double TimeMap_curFrameRate(ReaProject proj, bool &dropFrame)
number retval, boolean dropFrame = reaper.TimeMap_curFrameRate(ReaProject proj)
(Float retval, ReaProject proj, Boolean dropFrameOut) = RPR_TimeMap_curFrameRate(proj, dropFrameOut)

Gets project framerate, and optionally whether it is drop-frame timecode

double TimeMap_GetDividedBpmAtTime(double time)
double TimeMap_GetDividedBpmAtTime(time)
number reaper.TimeMap_GetDividedBpmAtTime(number time)
Float RPR_TimeMap_GetDividedBpmAtTime(Float time)

get the effective BPM at the time (seconds) position (i.e. 2x in /8 signatures)

double TimeMap_GetMeasureInfo(ReaProject* proj, int measure, double* qn_startOut, double* qn_endOut, int* timesig_numOut, int* timesig_denomOut, double* tempoOut)
double TimeMap_GetMeasureInfo(ReaProject proj, int measure, &qn_start, &qn_end, int &timesig_num, int &timesig_denom, &tempo)
number retval, number qn_start, number qn_end, integer timesig_num, integer timesig_denom, number tempo = reaper.TimeMap_GetMeasureInfo(ReaProject proj, integer measure)
(Float retval, ReaProject proj, Int measure, Float qn_startOut, Float qn_endOut, Int timesig_numOut, Int timesig_denomOut, Float tempoOut) = RPR_TimeMap_GetMeasureInfo(proj, measure, qn_startOut, qn_endOut, timesig_numOut, timesig_denomOut, tempoOut)

Get the QN position and time signature information for the start of a measure. Return the time in seconds of the measure start.

int TimeMap_GetMetronomePattern(ReaProject* proj, double time, char* pattern, int pattern_sz)
int TimeMap_GetMetronomePattern(ReaProject proj, time, #pattern)
integer retval, string pattern = reaper.TimeMap_GetMetronomePattern(ReaProject proj, number time, string pattern)
(Int retval, ReaProject proj, Float time, String pattern, Int pattern_sz) = RPR_TimeMap_GetMetronomePattern(proj, time, pattern, pattern_sz)

Fills in a string representing the active metronome pattern. For example, in a 7/8 measure divided 3+4, the pattern might be "1221222". The length of the string is the time signature numerator, and the function returns the time signature denominator.

void TimeMap_GetTimeSigAtTime(ReaProject* proj, double time, int* timesig_numOut, int* timesig_denomOut, double* tempoOut)
TimeMap_GetTimeSigAtTime(ReaProject proj, time, int &timesig_num, int &timesig_denom, &tempo)
integer timesig_num, integer timesig_denom, number tempo = reaper.TimeMap_GetTimeSigAtTime(ReaProject proj, number time)
(ReaProject proj, Float time, Int timesig_numOut, Int timesig_denomOut, Float tempoOut) = RPR_TimeMap_GetTimeSigAtTime(proj, time, timesig_numOut, timesig_denomOut, tempoOut)

get the effective time signature and tempo

int TimeMap_QNToMeasures(ReaProject* proj, double qn, double* qnMeasureStartOutOptional, double* qnMeasureEndOutOptional)
int TimeMap_QNToMeasures(ReaProject proj, qn, optional &qnMeasureStart, optional &qnMeasureEnd)
integer retval, optional number qnMeasureStart, optional number qnMeasureEnd = reaper.TimeMap_QNToMeasures(ReaProject proj, number qn)
(Int retval, ReaProject proj, Float qn, Float qnMeasureStartOutOptional, Float qnMeasureEndOutOptional) = RPR_TimeMap_QNToMeasures(proj, qn, qnMeasureStartOutOptional, qnMeasureEndOutOptional)

Find which measure the given QN position falls in.

double TimeMap_QNToTime(double qn)
double TimeMap_QNToTime(qn)
number reaper.TimeMap_QNToTime(number qn)
Float RPR_TimeMap_QNToTime(Float qn)

converts project QN position to time.

double TimeMap_QNToTime_abs(ReaProject* proj, double qn)
double TimeMap_QNToTime_abs(ReaProject proj, qn)
number reaper.TimeMap_QNToTime_abs(ReaProject proj, number qn)
Float RPR_TimeMap_QNToTime_abs(ReaProject proj, Float qn)

Converts project quarter note count (QN) to time. QN is counted from the start of the project, regardless of any partial measures. See TimeMap2_QNToTime

double TimeMap_timeToQN(double tpos)
double TimeMap_timeToQN(tpos)
number reaper.TimeMap_timeToQN(number tpos)
Float RPR_TimeMap_timeToQN(Float tpos)

converts project QN position to time.

double TimeMap_timeToQN_abs(ReaProject* proj, double tpos)
double TimeMap_timeToQN_abs(ReaProject proj, tpos)
number reaper.TimeMap_timeToQN_abs(ReaProject proj, number tpos)
Float RPR_TimeMap_timeToQN_abs(ReaProject proj, Float tpos)

Converts project time position to quarter note count (QN). QN is counted from the start of the project, regardless of any partial measures. See TimeMap2_timeToQN

bool ToggleTrackSendUIMute(MediaTrack* track, int send_idx)
bool ToggleTrackSendUIMute(MediaTrack track, int send_idx)
boolean reaper.ToggleTrackSendUIMute(MediaTrack track, integer send_idx)
Boolean RPR_ToggleTrackSendUIMute(MediaTrack track, Int send_idx)

send_idx<0 for receives, >=0 for hw ouputs, >=nb_of_hw_ouputs for sends.

double Track_GetPeakHoldDB(MediaTrack* track, int channel, bool clear)
double Track_GetPeakHoldDB(MediaTrack track, int channel, bool clear)
number reaper.Track_GetPeakHoldDB(MediaTrack track, integer channel, boolean clear)
Float RPR_Track_GetPeakHoldDB(MediaTrack track, Int channel, Boolean clear)

Returns meter hold state, in dB*0.01 (0 = +0dB, -0.01 = -1dB, 0.02 = +2dB, etc). If clear is set, clears the meter hold. If channel==1024 or channel==1025, returns loudness values if this is the master track or this track's VU meters are set to display loudness.

double Track_GetPeakInfo(MediaTrack* track, int channel)
double Track_GetPeakInfo(MediaTrack track, int channel)
number reaper.Track_GetPeakInfo(MediaTrack track, integer channel)
Float RPR_Track_GetPeakInfo(MediaTrack track, Int channel)

Returns peak meter value (1.0=+0dB, 0.0=-inf) for channel. If channel==1024 or channel==1025, returns loudness values if this is the master track or this track's VU meters are set to display loudness.

void TrackCtl_SetToolTip(const char* fmt, int xpos, int ypos, bool topmost)
TrackCtl_SetToolTip("fmt", int xpos, int ypos, bool topmost)
reaper.TrackCtl_SetToolTip(string fmt, integer xpos, integer ypos, boolean topmost)
RPR_TrackCtl_SetToolTip(String fmt, Int xpos, Int ypos, Boolean topmost)

displays tooltip at location, or removes if empty string

int TrackFX_AddByName(MediaTrack* track, const char* fxname, bool recFX, int instantiate)
int TrackFX_AddByName(MediaTrack track, "fxname", bool recFX, int instantiate)
integer reaper.TrackFX_AddByName(MediaTrack track, string fxname, boolean recFX, integer instantiate)
Int RPR_TrackFX_AddByName(MediaTrack track, String fxname, Boolean recFX, Int instantiate)

Adds or queries the position of a named FX from the track FX chain (recFX=false) or record input FX/monitoring FX (recFX=true, monitoring FX are on master track). Specify a negative value for instantiate to always create a new effect, 0 to only query the first instance of an effect, or a positive value to add an instance if one is not found. If instantiate is <= -1000, it is used for the insertion position (-1000 is first item in chain, -1001 is second, etc). fxname can have prefix to specify type: VST3:,VST2:,VST:,AU:,JS:, or DX:, or FXADD: which adds selected items from the currently-open FX browser, FXADD:2 to limit to 2 FX added, or FXADD:2e to only succeed if exactly 2 FX are selected. Returns -1 on failure or the new position in chain on success. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TrackFX_CopyToTake(MediaTrack* src_track, int src_fx, MediaItem_Take* dest_take, int dest_fx, bool is_move)
TrackFX_CopyToTake(MediaTrack src_track, int src_fx, MediaItem_Take dest_take, int dest_fx, bool is_move)
reaper.TrackFX_CopyToTake(MediaTrack src_track, integer src_fx, MediaItem_Take dest_take, integer dest_fx, boolean is_move)
RPR_TrackFX_CopyToTake(MediaTrack src_track, Int src_fx, MediaItem_Take dest_take, Int dest_fx, Boolean is_move)

Copies (or moves) FX from src_track to dest_take. src_fx can have 0x1000000 set to reference input FX. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TrackFX_CopyToTrack(MediaTrack* src_track, int src_fx, MediaTrack* dest_track, int dest_fx, bool is_move)
TrackFX_CopyToTrack(MediaTrack src_track, int src_fx, MediaTrack dest_track, int dest_fx, bool is_move)
reaper.TrackFX_CopyToTrack(MediaTrack src_track, integer src_fx, MediaTrack dest_track, integer dest_fx, boolean is_move)
RPR_TrackFX_CopyToTrack(MediaTrack src_track, Int src_fx, MediaTrack dest_track, Int dest_fx, Boolean is_move)

Copies (or moves) FX from src_track to dest_track. Can be used with src_track=dest_track to reorder, FX indices have 0x1000000 set to reference input FX. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_Delete(MediaTrack* track, int fx)
bool TrackFX_Delete(MediaTrack track, int fx)
boolean reaper.TrackFX_Delete(MediaTrack track, integer fx)
Boolean RPR_TrackFX_Delete(MediaTrack track, Int fx)

Remove a FX from track chain (returns true on success) FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_EndParamEdit(MediaTrack* track, int fx, int param)
bool TrackFX_EndParamEdit(MediaTrack track, int fx, int param)
boolean reaper.TrackFX_EndParamEdit(MediaTrack track, integer fx, integer param)
Boolean RPR_TrackFX_EndParamEdit(MediaTrack track, Int fx, Int param)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_FormatParamValue(MediaTrack* track, int fx, int param, double val, char* bufOut, int bufOut_sz)
bool TrackFX_FormatParamValue(MediaTrack track, int fx, int param, val, #buf)
boolean retval, string buf = reaper.TrackFX_FormatParamValue(MediaTrack track, integer fx, integer param, number val)
(Boolean retval, MediaTrack track, Int fx, Int param, Float val, String bufOut, Int bufOut_sz) = RPR_TrackFX_FormatParamValue(track, fx, param, val, bufOut, bufOut_sz)

Note: only works with FX that support Cockos VST extensions. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_FormatParamValueNormalized(MediaTrack* track, int fx, int param, double value, char* buf, int buf_sz)
bool TrackFX_FormatParamValueNormalized(MediaTrack track, int fx, int param, value, #buf)
boolean retval, string buf = reaper.TrackFX_FormatParamValueNormalized(MediaTrack track, integer fx, integer param, number value, string buf)
(Boolean retval, MediaTrack track, Int fx, Int param, Float value, String buf, Int buf_sz) = RPR_TrackFX_FormatParamValueNormalized(track, fx, param, value, buf, buf_sz)

Note: only works with FX that support Cockos VST extensions. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TrackFX_GetByName(MediaTrack* track, const char* fxname, bool instantiate)
int TrackFX_GetByName(MediaTrack track, "fxname", bool instantiate)
integer reaper.TrackFX_GetByName(MediaTrack track, string fxname, boolean instantiate)
Int RPR_TrackFX_GetByName(MediaTrack track, String fxname, Boolean instantiate)

Get the index of the first track FX insert that matches fxname. If the FX is not in the chain and instantiate is true, it will be inserted. See TrackFX_GetInstrument, TrackFX_GetEQ. Deprecated in favor of TrackFX_AddByName.

int TrackFX_GetChainVisible(MediaTrack* track)
int TrackFX_GetChainVisible(MediaTrack track)
integer reaper.TrackFX_GetChainVisible(MediaTrack track)
Int RPR_TrackFX_GetChainVisible(MediaTrack track)

returns index of effect visible in chain, or -1 for chain hidden, or -2 for chain visible but no effect selected

int TrackFX_GetCount(MediaTrack* track)
int TrackFX_GetCount(MediaTrack track)
integer reaper.TrackFX_GetCount(MediaTrack track)
Int RPR_TrackFX_GetCount(MediaTrack track)
bool TrackFX_GetEnabled(MediaTrack* track, int fx)
bool TrackFX_GetEnabled(MediaTrack track, int fx)
boolean reaper.TrackFX_GetEnabled(MediaTrack track, integer fx)
Boolean RPR_TrackFX_GetEnabled(MediaTrack track, Int fx)

See TrackFX_SetEnabled FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TrackFX_GetEQ(MediaTrack* track, bool instantiate)
int TrackFX_GetEQ(MediaTrack track, bool instantiate)
integer reaper.TrackFX_GetEQ(MediaTrack track, boolean instantiate)
Int RPR_TrackFX_GetEQ(MediaTrack track, Boolean instantiate)

Get the index of ReaEQ in the track FX chain. If ReaEQ is not in the chain and instantiate is true, it will be inserted. See TrackFX_GetInstrument, TrackFX_GetByName.

bool TrackFX_GetEQBandEnabled(MediaTrack* track, int fxidx, int bandtype, int bandidx)
bool TrackFX_GetEQBandEnabled(MediaTrack track, int fxidx, int bandtype, int bandidx)
boolean reaper.TrackFX_GetEQBandEnabled(MediaTrack track, integer fxidx, integer bandtype, integer bandidx)
Boolean RPR_TrackFX_GetEQBandEnabled(MediaTrack track, Int fxidx, Int bandtype, Int bandidx)

Returns true if the EQ band is enabled.
Returns false if the band is disabled, or if track/fxidx is not ReaEQ.
Bandtype: -1=master gain, 0=hipass, 1=loshelf, 2=band, 3=notch, 4=hishelf, 5=lopass, 6=bandpass, 7=parallel bandpass.
Bandidx (ignored for master gain): 0=target first band matching bandtype, 1=target 2nd band matching bandtype, etc.

See TrackFX_GetEQ, TrackFX_GetEQParam, TrackFX_SetEQParam, TrackFX_SetEQBandEnabled. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetEQParam(MediaTrack* track, int fxidx, int paramidx, int* bandtypeOut, int* bandidxOut, int* paramtypeOut, double* normvalOut)
bool TrackFX_GetEQParam(MediaTrack track, int fxidx, int paramidx, int &bandtype, int &bandidx, int &paramtype, &normval)
boolean retval, integer bandtype, integer bandidx, integer paramtype, number normval = reaper.TrackFX_GetEQParam(MediaTrack track, integer fxidx, integer paramidx)
(Boolean retval, MediaTrack track, Int fxidx, Int paramidx, Int bandtypeOut, Int bandidxOut, Int paramtypeOut, Float normvalOut) = RPR_TrackFX_GetEQParam(track, fxidx, paramidx, bandtypeOut, bandidxOut, paramtypeOut, normvalOut)

Returns false if track/fxidx is not ReaEQ.
Bandtype: -1=master gain, 0=hipass, 1=loshelf, 2=band, 3=notch, 4=hishelf, 5=lopass, 6=bandpass, 7=parallel bandpass.
Bandidx (ignored for master gain): 0=target first band matching bandtype, 1=target 2nd band matching bandtype, etc.
Paramtype (ignored for master gain): 0=freq, 1=gain, 2=Q.
See TrackFX_GetEQ, TrackFX_SetEQParam, TrackFX_GetEQBandEnabled, TrackFX_SetEQBandEnabled. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

HWND TrackFX_GetFloatingWindow(MediaTrack* track, int index)
HWND TrackFX_GetFloatingWindow(MediaTrack track, int index)
HWND reaper.TrackFX_GetFloatingWindow(MediaTrack track, integer index)
HWND RPR_TrackFX_GetFloatingWindow(MediaTrack track, Int index)

returns HWND of floating window for effect index, if any FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetFormattedParamValue(MediaTrack* track, int fx, int param, char* bufOut, int bufOut_sz)
bool TrackFX_GetFormattedParamValue(MediaTrack track, int fx, int param, #buf)
boolean retval, string buf = reaper.TrackFX_GetFormattedParamValue(MediaTrack track, integer fx, integer param)
(Boolean retval, MediaTrack track, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TrackFX_GetFormattedParamValue(track, fx, param, bufOut, bufOut_sz)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

GUID* TrackFX_GetFXGUID(MediaTrack* track, int fx)
bool TrackFX_GetFXGUID(#retguid, MediaTrack track, int fx)
string GUID = reaper.TrackFX_GetFXGUID(MediaTrack track, integer fx)
GUID RPR_TrackFX_GetFXGUID(MediaTrack track, Int fx)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetFXName(MediaTrack* track, int fx, char* bufOut, int bufOut_sz)
bool TrackFX_GetFXName(MediaTrack track, int fx, #buf)
boolean retval, string buf = reaper.TrackFX_GetFXName(MediaTrack track, integer fx)
(Boolean retval, MediaTrack track, Int fx, String bufOut, Int bufOut_sz) = RPR_TrackFX_GetFXName(track, fx, bufOut, bufOut_sz)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TrackFX_GetInstrument(MediaTrack* track)
int TrackFX_GetInstrument(MediaTrack track)
integer reaper.TrackFX_GetInstrument(MediaTrack track)
Int RPR_TrackFX_GetInstrument(MediaTrack track)

Get the index of the first track FX insert that is a virtual instrument, or -1 if none. See TrackFX_GetEQ, TrackFX_GetByName.

int TrackFX_GetIOSize(MediaTrack* track, int fx, int* inputPinsOut, int* outputPinsOut)
int TrackFX_GetIOSize(MediaTrack track, int fx, int &inputPins, int &outputPins)
integer retval, integer inputPins, integer outputPins = reaper.TrackFX_GetIOSize(MediaTrack track, integer fx)
(Int retval, MediaTrack track, Int fx, Int inputPinsOut, Int outputPinsOut) = RPR_TrackFX_GetIOSize(track, fx, inputPinsOut, outputPinsOut)

Gets the number of input/output pins for FX if available, returns plug-in type or -1 on error FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetNamedConfigParm(MediaTrack* track, int fx, const char* parmname, char* bufOutNeedBig, int bufOutNeedBig_sz)
bool TrackFX_GetNamedConfigParm(MediaTrack track, int fx, "parmname", #buf)
boolean retval, string buf = reaper.TrackFX_GetNamedConfigParm(MediaTrack track, integer fx, string parmname)
(Boolean retval, MediaTrack track, Int fx, String parmname, String bufOutNeedBig, Int bufOutNeedBig_sz) = RPR_TrackFX_GetNamedConfigParm(track, fx, parmname, bufOutNeedBig, bufOutNeedBig_sz)

gets plug-in specific named configuration value (returns true on success).

Supported values for read:
pdc : PDC latency
in_pin_X : name of input pin X
out_pin_X : name of output pin X
fx_type : type string
fx_ident : type-specific identifier
fx_name : name of FX (also supported as original_name)
GainReduction_dB : [ReaComp + other supported compressors]
parent_container : FX ID of parent container, if any (v7.06+)
container_count : [Container] number of FX in container
container_item.X : FX ID of item in container (first item is container_item.0) (v7.06+)
param.X.container_map.hint_id : unique ID of mapping (preserved if mapping order changes)
param.X.container_map.delete : read this value in order to remove the mapping for this parameter
container_map.add : read from this value to add a new container parameter mapping -- will return new parameter index (accessed via param.X.container_map.*)
container_map.add.FXID.PARMIDX : read from this value to add/get container parameter mapping for FXID/PARMIDX -- will return the parameter index (accessed via param.X.container_map.*). FXID can be a full address (must be a child of the container) or a 0-based sub-index (v7.06+).
container_map.get.FXID.PARMIDX : read from this value to get container parameter mapping for FXID/PARMIDX -- will return the parameter index (accessed via param.X.container_map.*). FXID can be a full address (must be a child of the container) or a 0-based sub-index (v7.06+).

Supported values for read/write:
vst_chunk[_program] : base64-encoded VST-specific chunk.
clap_chunk : base64-encoded CLAP-specific chunk.
param.X.lfo.[active,dir,phase,speed,strength,temposync,free,shape] : parameter moduation LFO state
param.X.acs.[active,dir,strength,attack,release,dblo,dbhi,chan,stereo,x2,y2] : parameter modulation ACS state
param.X.plink.[active,scale,offset,effect,param,midi_bus,midi_chan,midi_msg,midi_msg2] : parameter link/MIDI link: set effect=-100 to support midi_*
param.X.mod.[active,baseline,visible] : parameter module global settings
param.X.learn.[midi1,midi2,osc] : first two bytes of MIDI message, or OSC string if set
param.X.learn.mode : absolution/relative mode flag (0: Absolute, 1: 127=-1,1=+1, 2: 63=-1, 65=+1, 3: 65=-1, 1=+1, 4: toggle if nonzero)
param.X.learn.flags : &1=selected track only, &2=soft takeover, &4=focused FX only, &8=LFO retrigger, &16=visible FX only
param.X.container_map.fx_index : index of FX contained in container
param.X.container_map.fx_parm : parameter index of parameter of FX contained in container
param.X.container_map.aliased_name : name of parameter (if user-renamed, otherwise fails)
BANDTYPEx, BANDENABLEDx : band configuration [ReaEQ]
THRESHOLD, CEILING, TRUEPEAK : [ReaLimit]
NUMCHANNELS, NUMSPEAKERS, RESETCHANNELS : [ReaSurroundPan]
ITEMx : [ReaVerb] state configuration line, when writing should be followed by a write of DONE
FILE, FILEx, -FILEx, +FILEx, -FILE* : [RS5k] file list, -/+ prefixes are write-only, when writing any, should be followed by a write of DONE
MODE, RSMODE : [RS5k] general mode, resample mode
VIDEO_CODE : [video processor] code
force_auto_bypass : 0 or 1 - force auto-bypass plug-in on silence
parallel : 0, 1 or 2 - 1=process plug-in in parallel with previous, 2=process plug-in parallel and merge MIDI
instance_oversample_shift : instance oversampling shift amount, 0=none, 1=~96k, 2=~192k, etc. When setting requires playback stop/start to take effect
chain_oversample_shift : chain oversampling shift amount, 0=none, 1=~96k, 2=~192k, etc. When setting requires playback stop/start to take effect
chain_pdc_mode : chain PDC mode (0=classic, 1=new-default, 2=ignore PDC, 3=hwcomp-master)
chain_sel : selected/visible FX in chain
renamed_name : renamed FX instance name (empty string = not renamed)
container_nch : number of internal channels for container
container_nch_in : number of input pins for container
container_nch_out : number of output pints for container
container_nch_feedback : number of internal feedback channels enabled in container
focused : reading returns 1 if focused. Writing a positive value to this sets the FX UI as "last focused."
last_touched : reading returns two integers, one indicates whether FX is the last-touched FX, the second indicates which parameter was last touched. Writing a negative value ensures this plug-in is not set as last touched, otherwise the FX is set "last touched," and last touched parameter index is set to the value in the string (if valid).
FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TrackFX_GetNumParams(MediaTrack* track, int fx)
int TrackFX_GetNumParams(MediaTrack track, int fx)
integer reaper.TrackFX_GetNumParams(MediaTrack track, integer fx)
Int RPR_TrackFX_GetNumParams(MediaTrack track, Int fx)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetOffline(MediaTrack* track, int fx)
bool TrackFX_GetOffline(MediaTrack track, int fx)
boolean reaper.TrackFX_GetOffline(MediaTrack track, integer fx)
Boolean RPR_TrackFX_GetOffline(MediaTrack track, Int fx)

See TrackFX_SetOffline FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetOpen(MediaTrack* track, int fx)
bool TrackFX_GetOpen(MediaTrack track, int fx)
boolean reaper.TrackFX_GetOpen(MediaTrack track, integer fx)
Boolean RPR_TrackFX_GetOpen(MediaTrack track, Int fx)

Returns true if this FX UI is open in the FX chain window or a floating window. See TrackFX_SetOpen FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

double TrackFX_GetParam(MediaTrack* track, int fx, int param, double* minvalOut, double* maxvalOut)
double TrackFX_GetParam(MediaTrack track, int fx, int param, &minval, &maxval)
number retval, number minval, number maxval = reaper.TrackFX_GetParam(MediaTrack track, integer fx, integer param)
(Float retval, MediaTrack track, Int fx, Int param, Float minvalOut, Float maxvalOut) = RPR_TrackFX_GetParam(track, fx, param, minvalOut, maxvalOut)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetParameterStepSizes(MediaTrack* track, int fx, int param, double* stepOut, double* smallstepOut, double* largestepOut, bool* istoggleOut)
bool TrackFX_GetParameterStepSizes(MediaTrack track, int fx, int param, &step, &smallstep, &largestep, bool &istoggle)
boolean retval, number step, number smallstep, number largestep, boolean istoggle = reaper.TrackFX_GetParameterStepSizes(MediaTrack track, integer fx, integer param)
(Boolean retval, MediaTrack track, Int fx, Int param, Float stepOut, Float smallstepOut, Float largestepOut, Boolean istoggleOut) = RPR_TrackFX_GetParameterStepSizes(track, fx, param, stepOut, smallstepOut, largestepOut, istoggleOut)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

double TrackFX_GetParamEx(MediaTrack* track, int fx, int param, double* minvalOut, double* maxvalOut, double* midvalOut)
double TrackFX_GetParamEx(MediaTrack track, int fx, int param, &minval, &maxval, &midval)
number retval, number minval, number maxval, number midval = reaper.TrackFX_GetParamEx(MediaTrack track, integer fx, integer param)
(Float retval, MediaTrack track, Int fx, Int param, Float minvalOut, Float maxvalOut, Float midvalOut) = RPR_TrackFX_GetParamEx(track, fx, param, minvalOut, maxvalOut, midvalOut)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TrackFX_GetParamFromIdent(MediaTrack* track, int fx, const char* ident_str)
int TrackFX_GetParamFromIdent(MediaTrack track, int fx, "ident_str")
integer reaper.TrackFX_GetParamFromIdent(MediaTrack track, integer fx, string ident_str)
Int RPR_TrackFX_GetParamFromIdent(MediaTrack track, Int fx, String ident_str)

gets the parameter index from an identifying string (:wet, :bypass, :delta, or a string returned from GetParamIdent), or -1 if unknown. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetParamIdent(MediaTrack* track, int fx, int param, char* bufOut, int bufOut_sz)
bool TrackFX_GetParamIdent(MediaTrack track, int fx, int param, #buf)
boolean retval, string buf = reaper.TrackFX_GetParamIdent(MediaTrack track, integer fx, integer param)
(Boolean retval, MediaTrack track, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TrackFX_GetParamIdent(track, fx, param, bufOut, bufOut_sz)

gets an identifying string for the parameter FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetParamName(MediaTrack* track, int fx, int param, char* bufOut, int bufOut_sz)
bool TrackFX_GetParamName(MediaTrack track, int fx, int param, #buf)
boolean retval, string buf = reaper.TrackFX_GetParamName(MediaTrack track, integer fx, integer param)
(Boolean retval, MediaTrack track, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TrackFX_GetParamName(track, fx, param, bufOut, bufOut_sz)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

double TrackFX_GetParamNormalized(MediaTrack* track, int fx, int param)
double TrackFX_GetParamNormalized(MediaTrack track, int fx, int param)
number reaper.TrackFX_GetParamNormalized(MediaTrack track, integer fx, integer param)
Float RPR_TrackFX_GetParamNormalized(MediaTrack track, Int fx, Int param)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TrackFX_GetPinMappings(MediaTrack* tr, int fx, int isoutput, int pin, int* high32Out)
int TrackFX_GetPinMappings(MediaTrack tr, int fx, int isoutput, int pin, int &high32)
integer retval, integer high32 = reaper.TrackFX_GetPinMappings(MediaTrack tr, integer fx, integer isoutput, integer pin)
(Int retval, MediaTrack tr, Int fx, Int isoutput, Int pin, Int high32Out) = RPR_TrackFX_GetPinMappings(tr, fx, isoutput, pin, high32Out)

gets the effective channel mapping bitmask for a particular pin. high32Out will be set to the high 32 bits. Add 0x1000000 to pin index in order to access the second 64 bits of mappings independent of the first 64 bits. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_GetPreset(MediaTrack* track, int fx, char* presetnameOut, int presetnameOut_sz)
bool TrackFX_GetPreset(MediaTrack track, int fx, #presetname)
boolean retval, string presetname = reaper.TrackFX_GetPreset(MediaTrack track, integer fx)
(Boolean retval, MediaTrack track, Int fx, String presetnameOut, Int presetnameOut_sz) = RPR_TrackFX_GetPreset(track, fx, presetnameOut, presetnameOut_sz)

Get the name of the preset currently showing in the REAPER dropdown, or the full path to a factory preset file for VST3 plug-ins (.vstpreset). See TrackFX_SetPreset. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TrackFX_GetPresetIndex(MediaTrack* track, int fx, int* numberOfPresetsOut)
int TrackFX_GetPresetIndex(MediaTrack track, int fx, int &numberOfPresets)
integer retval, integer numberOfPresets = reaper.TrackFX_GetPresetIndex(MediaTrack track, integer fx)
(Int retval, MediaTrack track, Int fx, Int numberOfPresetsOut) = RPR_TrackFX_GetPresetIndex(track, fx, numberOfPresetsOut)

Returns current preset index, or -1 if error. numberOfPresetsOut will be set to total number of presets available. See TrackFX_SetPresetByIndex FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

int TrackFX_GetRecChainVisible(MediaTrack* track)
int TrackFX_GetRecChainVisible(MediaTrack track)
integer reaper.TrackFX_GetRecChainVisible(MediaTrack track)
Int RPR_TrackFX_GetRecChainVisible(MediaTrack track)

returns index of effect visible in record input chain, or -1 for chain hidden, or -2 for chain visible but no effect selected

int TrackFX_GetRecCount(MediaTrack* track)
int TrackFX_GetRecCount(MediaTrack track)
integer reaper.TrackFX_GetRecCount(MediaTrack track)
Int RPR_TrackFX_GetRecCount(MediaTrack track)

returns count of record input FX. To access record input FX, use a FX indices [0x1000000..0x1000000+n). On the master track, this accesses monitoring FX rather than record input FX.

void TrackFX_GetUserPresetFilename(MediaTrack* track, int fx, char* fnOut, int fnOut_sz)
TrackFX_GetUserPresetFilename(MediaTrack track, int fx, #fn)
string fn = reaper.TrackFX_GetUserPresetFilename(MediaTrack track, integer fx)
(MediaTrack track, Int fx, String fnOut, Int fnOut_sz) = RPR_TrackFX_GetUserPresetFilename(track, fx, fnOut, fnOut_sz)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_NavigatePresets(MediaTrack* track, int fx, int presetmove)
bool TrackFX_NavigatePresets(MediaTrack track, int fx, int presetmove)
boolean reaper.TrackFX_NavigatePresets(MediaTrack track, integer fx, integer presetmove)
Boolean RPR_TrackFX_NavigatePresets(MediaTrack track, Int fx, Int presetmove)

presetmove==1 activates the next preset, presetmove==-1 activates the previous preset, etc. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TrackFX_SetEnabled(MediaTrack* track, int fx, bool enabled)
TrackFX_SetEnabled(MediaTrack track, int fx, bool enabled)
reaper.TrackFX_SetEnabled(MediaTrack track, integer fx, boolean enabled)
RPR_TrackFX_SetEnabled(MediaTrack track, Int fx, Boolean enabled)

See TrackFX_GetEnabled FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_SetEQBandEnabled(MediaTrack* track, int fxidx, int bandtype, int bandidx, bool enable)
bool TrackFX_SetEQBandEnabled(MediaTrack track, int fxidx, int bandtype, int bandidx, bool enable)
boolean reaper.TrackFX_SetEQBandEnabled(MediaTrack track, integer fxidx, integer bandtype, integer bandidx, boolean enable)
Boolean RPR_TrackFX_SetEQBandEnabled(MediaTrack track, Int fxidx, Int bandtype, Int bandidx, Boolean enable)

Enable or disable a ReaEQ band.
Returns false if track/fxidx is not ReaEQ.
Bandtype: -1=master gain, 0=hipass, 1=loshelf, 2=band, 3=notch, 4=hishelf, 5=lopass, 6=bandpass, 7=parallel bandpass.
Bandidx (ignored for master gain): 0=target first band matching bandtype, 1=target 2nd band matching bandtype, etc.

See TrackFX_GetEQ, TrackFX_GetEQParam, TrackFX_SetEQParam, TrackFX_GetEQBandEnabled. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_SetEQParam(MediaTrack* track, int fxidx, int bandtype, int bandidx, int paramtype, double val, bool isnorm)
bool TrackFX_SetEQParam(MediaTrack track, int fxidx, int bandtype, int bandidx, int paramtype, val, bool isnorm)
boolean reaper.TrackFX_SetEQParam(MediaTrack track, integer fxidx, integer bandtype, integer bandidx, integer paramtype, number val, boolean isnorm)
Boolean RPR_TrackFX_SetEQParam(MediaTrack track, Int fxidx, Int bandtype, Int bandidx, Int paramtype, Float val, Boolean isnorm)

Returns false if track/fxidx is not ReaEQ. Targets a band matching bandtype.
Bandtype: -1=master gain, 0=hipass, 1=loshelf, 2=band, 3=notch, 4=hishelf, 5=lopass, 6=bandpass, 7=parallel bandpass.
Bandidx (ignored for master gain): 0=target first band matching bandtype, 1=target 2nd band matching bandtype, etc.
Paramtype (ignored for master gain): 0=freq, 1=gain, 2=Q.
See TrackFX_GetEQ, TrackFX_GetEQParam, TrackFX_GetEQBandEnabled, TrackFX_SetEQBandEnabled. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_SetNamedConfigParm(MediaTrack* track, int fx, const char* parmname, const char* value)
bool TrackFX_SetNamedConfigParm(MediaTrack track, int fx, "parmname", "value")
boolean reaper.TrackFX_SetNamedConfigParm(MediaTrack track, integer fx, string parmname, string value)
Boolean RPR_TrackFX_SetNamedConfigParm(MediaTrack track, Int fx, String parmname, String value)

sets plug-in specific named configuration value (returns true on success).

Support values for write:
vst_chunk[_program] : base64-encoded VST-specific chunk.
clap_chunk : base64-encoded CLAP-specific chunk.
param.X.lfo.[active,dir,phase,speed,strength,temposync,free,shape] : parameter moduation LFO state
param.X.acs.[active,dir,strength,attack,release,dblo,dbhi,chan,stereo,x2,y2] : parameter modulation ACS state
param.X.plink.[active,scale,offset,effect,param,midi_bus,midi_chan,midi_msg,midi_msg2] : parameter link/MIDI link: set effect=-100 to support midi_*
param.X.mod.[active,baseline,visible] : parameter module global settings
param.X.learn.[midi1,midi2,osc] : first two bytes of MIDI message, or OSC string if set
param.X.learn.mode : absolution/relative mode flag (0: Absolute, 1: 127=-1,1=+1, 2: 63=-1, 65=+1, 3: 65=-1, 1=+1, 4: toggle if nonzero)
param.X.learn.flags : &1=selected track only, &2=soft takeover, &4=focused FX only, &8=LFO retrigger, &16=visible FX only
param.X.container_map.fx_index : index of FX contained in container
param.X.container_map.fx_parm : parameter index of parameter of FX contained in container
param.X.container_map.aliased_name : name of parameter (if user-renamed, otherwise fails)
BANDTYPEx, BANDENABLEDx : band configuration [ReaEQ]
THRESHOLD, CEILING, TRUEPEAK : [ReaLimit]
NUMCHANNELS, NUMSPEAKERS, RESETCHANNELS : [ReaSurroundPan]
ITEMx : [ReaVerb] state configuration line, when writing should be followed by a write of DONE
FILE, FILEx, -FILEx, +FILEx, -FILE* : [RS5k] file list, -/+ prefixes are write-only, when writing any, should be followed by a write of DONE
MODE, RSMODE : [RS5k] general mode, resample mode
VIDEO_CODE : [video processor] code
force_auto_bypass : 0 or 1 - force auto-bypass plug-in on silence
parallel : 0, 1 or 2 - 1=process plug-in in parallel with previous, 2=process plug-in parallel and merge MIDI
instance_oversample_shift : instance oversampling shift amount, 0=none, 1=~96k, 2=~192k, etc. When setting requires playback stop/start to take effect
chain_oversample_shift : chain oversampling shift amount, 0=none, 1=~96k, 2=~192k, etc. When setting requires playback stop/start to take effect
chain_pdc_mode : chain PDC mode (0=classic, 1=new-default, 2=ignore PDC, 3=hwcomp-master)
chain_sel : selected/visible FX in chain
renamed_name : renamed FX instance name (empty string = not renamed)
container_nch : number of internal channels for container
container_nch_in : number of input pins for container
container_nch_out : number of output pints for container
container_nch_feedback : number of internal feedback channels enabled in container
focused : reading returns 1 if focused. Writing a positive value to this sets the FX UI as "last focused."
last_touched : reading returns two integers, one indicates whether FX is the last-touched FX, the second indicates which parameter was last touched. Writing a negative value ensures this plug-in is not set as last touched, otherwise the FX is set "last touched," and last touched parameter index is set to the value in the string (if valid).
FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TrackFX_SetOffline(MediaTrack* track, int fx, bool offline)
TrackFX_SetOffline(MediaTrack track, int fx, bool offline)
reaper.TrackFX_SetOffline(MediaTrack track, integer fx, boolean offline)
RPR_TrackFX_SetOffline(MediaTrack track, Int fx, Boolean offline)

See TrackFX_GetOffline FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TrackFX_SetOpen(MediaTrack* track, int fx, bool open)
TrackFX_SetOpen(MediaTrack track, int fx, bool open)
reaper.TrackFX_SetOpen(MediaTrack track, integer fx, boolean open)
RPR_TrackFX_SetOpen(MediaTrack track, Int fx, Boolean open)

Open this FX UI. See TrackFX_GetOpen FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_SetParam(MediaTrack* track, int fx, int param, double val)
bool TrackFX_SetParam(MediaTrack track, int fx, int param, val)
boolean reaper.TrackFX_SetParam(MediaTrack track, integer fx, integer param, number val)
Boolean RPR_TrackFX_SetParam(MediaTrack track, Int fx, Int param, Float val)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_SetParamNormalized(MediaTrack* track, int fx, int param, double value)
bool TrackFX_SetParamNormalized(MediaTrack track, int fx, int param, value)
boolean reaper.TrackFX_SetParamNormalized(MediaTrack track, integer fx, integer param, number value)
Boolean RPR_TrackFX_SetParamNormalized(MediaTrack track, Int fx, Int param, Float value)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_SetPinMappings(MediaTrack* tr, int fx, int isoutput, int pin, int low32bits, int hi32bits)
bool TrackFX_SetPinMappings(MediaTrack tr, int fx, int isoutput, int pin, int low32bits, int hi32bits)
boolean reaper.TrackFX_SetPinMappings(MediaTrack tr, integer fx, integer isoutput, integer pin, integer low32bits, integer hi32bits)
Boolean RPR_TrackFX_SetPinMappings(MediaTrack tr, Int fx, Int isoutput, Int pin, Int low32bits, Int hi32bits)

sets the channel mapping bitmask for a particular pin. returns false if unsupported (not all types of plug-ins support this capability). Add 0x1000000 to pin index in order to access the second 64 bits of mappings independent of the first 64 bits. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_SetPreset(MediaTrack* track, int fx, const char* presetname)
bool TrackFX_SetPreset(MediaTrack track, int fx, "presetname")
boolean reaper.TrackFX_SetPreset(MediaTrack track, integer fx, string presetname)
Boolean RPR_TrackFX_SetPreset(MediaTrack track, Int fx, String presetname)

Activate a preset with the name shown in the REAPER dropdown. Full paths to .vstpreset files are also supported for VST3 plug-ins. See TrackFX_GetPreset. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

bool TrackFX_SetPresetByIndex(MediaTrack* track, int fx, int idx)
bool TrackFX_SetPresetByIndex(MediaTrack track, int fx, int idx)
boolean reaper.TrackFX_SetPresetByIndex(MediaTrack track, integer fx, integer idx)
Boolean RPR_TrackFX_SetPresetByIndex(MediaTrack track, Int fx, Int idx)

Sets the preset idx, or the factory preset (idx==-2), or the default user preset (idx==-1). Returns true on success. See TrackFX_GetPresetIndex. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TrackFX_Show(MediaTrack* track, int index, int showFlag)
TrackFX_Show(MediaTrack track, int index, int showFlag)
reaper.TrackFX_Show(MediaTrack track, integer index, integer showFlag)
RPR_TrackFX_Show(MediaTrack track, Int index, Int showFlag)

showflag=0 for hidechain, =1 for show chain(index valid), =2 for hide floating window(index valid), =3 for show floating window (index valid) FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.

void TrackList_AdjustWindows(bool isMinor)
TrackList_AdjustWindows(bool isMinor)
reaper.TrackList_AdjustWindows(boolean isMinor)
RPR_TrackList_AdjustWindows(Boolean isMinor)
void TrackList_UpdateAllExternalSurfaces()
TrackList_UpdateAllExternalSurfaces()
reaper.TrackList_UpdateAllExternalSurfaces()
RPR_TrackList_UpdateAllExternalSurfaces()
void Undo_BeginBlock()
Undo_BeginBlock()
reaper.Undo_BeginBlock()
RPR_Undo_BeginBlock()

call to start a new block

void Undo_BeginBlock2(ReaProject* proj)
Undo_BeginBlock2(ReaProject proj)
reaper.Undo_BeginBlock2(ReaProject proj)
RPR_Undo_BeginBlock2(ReaProject proj)

call to start a new block

const char* Undo_CanRedo2(ReaProject* proj)
bool Undo_CanRedo2(#retval, ReaProject proj)
string reaper.Undo_CanRedo2(ReaProject proj)
String RPR_Undo_CanRedo2(ReaProject proj)

returns string of next action,if able,NULL if not

const char* Undo_CanUndo2(ReaProject* proj)
bool Undo_CanUndo2(#retval, ReaProject proj)
string reaper.Undo_CanUndo2(ReaProject proj)
String RPR_Undo_CanUndo2(ReaProject proj)

returns string of last action,if able,NULL if not

int Undo_DoRedo2(ReaProject* proj)
int Undo_DoRedo2(ReaProject proj)
integer reaper.Undo_DoRedo2(ReaProject proj)
Int RPR_Undo_DoRedo2(ReaProject proj)

nonzero if success

int Undo_DoUndo2(ReaProject* proj)
int Undo_DoUndo2(ReaProject proj)
integer reaper.Undo_DoUndo2(ReaProject proj)
Int RPR_Undo_DoUndo2(ReaProject proj)

nonzero if success

void Undo_EndBlock(const char* descchange, int extraflags)
Undo_EndBlock("descchange", int extraflags)
reaper.Undo_EndBlock(string descchange, integer extraflags)
RPR_Undo_EndBlock(String descchange, Int extraflags)

call to end the block,with extra flags if any,and a description

void Undo_EndBlock2(ReaProject* proj, const char* descchange, int extraflags)
Undo_EndBlock2(ReaProject proj, "descchange", int extraflags)
reaper.Undo_EndBlock2(ReaProject proj, string descchange, integer extraflags)
RPR_Undo_EndBlock2(ReaProject proj, String descchange, Int extraflags)

call to end the block,with extra flags if any,and a description

void Undo_OnStateChange(const char* descchange)
Undo_OnStateChange("descchange")
reaper.Undo_OnStateChange(string descchange)
RPR_Undo_OnStateChange(String descchange)

limited state change to items

void Undo_OnStateChange2(ReaProject* proj, const char* descchange)
Undo_OnStateChange2(ReaProject proj, "descchange")
reaper.Undo_OnStateChange2(ReaProject proj, string descchange)
RPR_Undo_OnStateChange2(ReaProject proj, String descchange)

limited state change to items

void Undo_OnStateChange_Item(ReaProject* proj, const char* name, MediaItem* item)
Undo_OnStateChange_Item(ReaProject proj, "name", MediaItem item)
reaper.Undo_OnStateChange_Item(ReaProject proj, string name, MediaItem item)
RPR_Undo_OnStateChange_Item(ReaProject proj, String name, MediaItem item)
void Undo_OnStateChangeEx(const char* descchange, int whichStates, int trackparm)
Undo_OnStateChangeEx("descchange", int whichStates, int trackparm)
reaper.Undo_OnStateChangeEx(string descchange, integer whichStates, integer trackparm)
RPR_Undo_OnStateChangeEx(String descchange, Int whichStates, Int trackparm)

trackparm=-1 by default,or if updating one fx chain,you can specify track index

void Undo_OnStateChangeEx2(ReaProject* proj, const char* descchange, int whichStates, int trackparm)
Undo_OnStateChangeEx2(ReaProject proj, "descchange", int whichStates, int trackparm)
reaper.Undo_OnStateChangeEx2(ReaProject proj, string descchange, integer whichStates, integer trackparm)
RPR_Undo_OnStateChangeEx2(ReaProject proj, String descchange, Int whichStates, Int trackparm)

trackparm=-1 by default,or if updating one fx chain,you can specify track index

void UpdateArrange()
UpdateArrange()
reaper.UpdateArrange()
RPR_UpdateArrange()

Redraw the arrange view

void UpdateItemInProject(MediaItem* item)
UpdateItemInProject(MediaItem item)
reaper.UpdateItemInProject(MediaItem item)
RPR_UpdateItemInProject(MediaItem item)
bool UpdateItemLanes(ReaProject* proj)
bool UpdateItemLanes(ReaProject proj)
boolean reaper.UpdateItemLanes(ReaProject proj)
Boolean RPR_UpdateItemLanes(ReaProject proj)

Recalculate lane arrangement for fixed lane tracks, including auto-removing empty lanes at the bottom of the track

void UpdateTimeline()
UpdateTimeline()
reaper.UpdateTimeline()
RPR_UpdateTimeline()

Redraw the arrange view and ruler

bool ValidatePtr(void* pointer, const char* ctypename)
bool ValidatePtr(void* pointer, "ctypename")
boolean reaper.ValidatePtr(identifier pointer, string ctypename)
Boolean RPR_ValidatePtr(void pointer, String ctypename)

see ValidatePtr2

bool ValidatePtr2(ReaProject* proj, void* pointer, const char* ctypename)
bool ValidatePtr2(ReaProject proj, void* pointer, "ctypename")
boolean reaper.ValidatePtr2(ReaProject proj, identifier pointer, string ctypename)
Boolean RPR_ValidatePtr2(ReaProject proj, void pointer, String ctypename)

Return true if the pointer is a valid object of the right type in proj (proj is ignored if pointer is itself a project). Supported types are: ReaProject*, MediaTrack*, MediaItem*, MediaItem_Take*, TrackEnvelope* and PCM_source*.

void ViewPrefs(int page, const char* pageByName)
ViewPrefs(int page, "pageByName")
reaper.ViewPrefs(integer page, string pageByName)
RPR_ViewPrefs(Int page, String pageByName)

Opens the prefs to a page, use pageByName if page is 0.

BR_Envelope* BR_EnvAlloc(TrackEnvelope* envelope, bool takeEnvelopesUseProjectTime)
BR_Envelope BR_EnvAlloc(TrackEnvelope envelope, bool takeEnvelopesUseProjectTime) (requires REAPER 6.24 or later)
BR_Envelope extension_api("BR_EnvAlloc", TrackEnvelope envelope, bool takeEnvelopesUseProjectTime) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
BR_Envelope reaper.BR_EnvAlloc(TrackEnvelope envelope, boolean takeEnvelopesUseProjectTime)
BR_Envelope BR_EnvAlloc(TrackEnvelope envelope, Boolean takeEnvelopesUseProjectTime)

[BR] Allocate envelope object from track or take envelope pointer. Always call BR_EnvFree when done to release the object and commit changes if needed.
takeEnvelopesUseProjectTime: take envelope points' positions are counted from take position, not project start time. If you want to work with project time instead, pass this as true.

For further manipulation see BR_EnvCountPoints, BR_EnvDeletePoint, BR_EnvFind, BR_EnvFindNext, BR_EnvFindPrevious, BR_EnvGetParentTake, BR_EnvGetParentTrack, BR_EnvGetPoint, BR_EnvGetProperties, BR_EnvSetPoint, BR_EnvSetProperties, BR_EnvValueAtPos.

int BR_EnvCountPoints(BR_Envelope* envelope)
int BR_EnvCountPoints(BR_Envelope envelope) (requires REAPER 6.24 or later)
int extension_api("BR_EnvCountPoints", BR_Envelope envelope) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_EnvCountPoints(BR_Envelope envelope)
Int BR_EnvCountPoints(BR_Envelope envelope)

[BR] Count envelope points in the envelope object allocated with BR_EnvAlloc.

bool BR_EnvDeletePoint(BR_Envelope* envelope, int id)
bool BR_EnvDeletePoint(BR_Envelope envelope, int id) (requires REAPER 6.24 or later)
bool extension_api("BR_EnvDeletePoint", BR_Envelope envelope, int id) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_EnvDeletePoint(BR_Envelope envelope, integer id)
Boolean BR_EnvDeletePoint(BR_Envelope envelope, Int id)

[BR] Delete envelope point by index (zero-based) in the envelope object allocated with BR_EnvAlloc. Returns true on success.

int BR_EnvFind(BR_Envelope* envelope, double position, double delta)
int BR_EnvFind(BR_Envelope envelope, position, delta) (requires REAPER 6.24 or later)
int extension_api("BR_EnvFind", BR_Envelope envelope, position, delta) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_EnvFind(BR_Envelope envelope, number position, number delta)
Int BR_EnvFind(BR_Envelope envelope, Float position, Float delta)

[BR] Find envelope point at time position in the envelope object allocated with BR_EnvAlloc. Pass delta > 0 to search surrounding range - in that case the closest point to position within delta will be searched for. Returns envelope point id (zero-based) on success or -1 on failure.

int BR_EnvFindNext(BR_Envelope* envelope, double position)
int BR_EnvFindNext(BR_Envelope envelope, position) (requires REAPER 6.24 or later)
int extension_api("BR_EnvFindNext", BR_Envelope envelope, position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_EnvFindNext(BR_Envelope envelope, number position)
Int BR_EnvFindNext(BR_Envelope envelope, Float position)

[BR] Find next envelope point after time position in the envelope object allocated with BR_EnvAlloc. Returns envelope point id (zero-based) on success or -1 on failure.

int BR_EnvFindPrevious(BR_Envelope* envelope, double position)
int BR_EnvFindPrevious(BR_Envelope envelope, position) (requires REAPER 6.24 or later)
int extension_api("BR_EnvFindPrevious", BR_Envelope envelope, position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_EnvFindPrevious(BR_Envelope envelope, number position)
Int BR_EnvFindPrevious(BR_Envelope envelope, Float position)

[BR] Find previous envelope point before time position in the envelope object allocated with BR_EnvAlloc. Returns envelope point id (zero-based) on success or -1 on failure.

bool BR_EnvFree(BR_Envelope* envelope, bool commit)
bool BR_EnvFree(BR_Envelope envelope, bool commit) (requires REAPER 6.24 or later)
bool extension_api("BR_EnvFree", BR_Envelope envelope, bool commit) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_EnvFree(BR_Envelope envelope, boolean commit)
Boolean BR_EnvFree(BR_Envelope envelope, Boolean commit)

[BR] Free envelope object allocated with BR_EnvAlloc and commit changes if needed. Returns true if changes were committed successfully. Note that when envelope object wasn't modified nothing will get committed even if commit = true - in that case function returns false.

MediaItem_Take* BR_EnvGetParentTake(BR_Envelope* envelope)
MediaItem_Take BR_EnvGetParentTake(BR_Envelope envelope) (requires REAPER 6.24 or later)
MediaItem_Take extension_api("BR_EnvGetParentTake", BR_Envelope envelope) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaItem_Take reaper.BR_EnvGetParentTake(BR_Envelope envelope)
MediaItem_Take BR_EnvGetParentTake(BR_Envelope envelope)

[BR] If envelope object allocated with BR_EnvAlloc is take envelope, returns parent media item take, otherwise NULL.

MediaTrack* BR_EnvGetParentTrack(BR_Envelope* envelope)
MediaTrack BR_EnvGetParentTrack(BR_Envelope envelope) (requires REAPER 6.24 or later)
MediaTrack extension_api("BR_EnvGetParentTrack", BR_Envelope envelope) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaTrack reaper.BR_EnvGetParentTrack(BR_Envelope envelope)
MediaTrack BR_EnvGetParentTrack(BR_Envelope envelope)

[BR] Get parent track of envelope object allocated with BR_EnvAlloc. If take envelope, returns NULL.

bool BR_EnvGetPoint(BR_Envelope* envelope, int id, double* positionOut, double* valueOut, int* shapeOut, bool* selectedOut, double* bezierOut)
bool BR_EnvGetPoint(BR_Envelope envelope, int id, &position, &value, int &shape, bool &selected, &bezier) (requires REAPER 6.24 or later)
bool extension_api("BR_EnvGetPoint", BR_Envelope envelope, int id, &position, &value, int &shape, bool &selected, &bezier) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number position, number value, integer shape, boolean selected, number bezier = reaper.BR_EnvGetPoint(BR_Envelope envelope, integer id)
(Boolean retval, BR_Envelope envelope, Int id, Float positionOut, Float valueOut, Int shapeOut, Boolean selectedOut, Float bezierOut) = BR_EnvGetPoint(envelope, id, positionOut, valueOut, shapeOut, selectedOut, bezierOut)

[BR] Get envelope point by id (zero-based) from the envelope object allocated with BR_EnvAlloc. Returns true on success.

void BR_EnvGetProperties(BR_Envelope* envelope, bool* activeOut, bool* visibleOut, bool* armedOut, bool* inLaneOut, int* laneHeightOut, int* defaultShapeOut, double* minValueOut, double* maxValueOut, double* centerValueOut, int* typeOut, bool* faderScalingOut, int* automationItemsOptionsOutOptional)
BR_EnvGetProperties(BR_Envelope envelope, bool &active, bool &visible, bool &armed, bool &inLane, int &laneHeight, int &defaultShape, &minValue, &maxValue, &centerValue, int &type, bool &faderScaling, optional int &automationItemsOptions) (requires REAPER 6.24 or later)
extension_api("BR_EnvGetProperties", BR_Envelope envelope, bool &active, bool &visible, bool &armed, bool &inLane, int &laneHeight, int &defaultShape, &minValue, &maxValue, &centerValue, int &type, bool &faderScaling, optional int &automationItemsOptions) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean active, boolean visible, boolean armed, boolean inLane, integer laneHeight, integer defaultShape, number minValue, number maxValue, number centerValue, integer type, boolean faderScaling, optional integer automationItemsOptions = reaper.BR_EnvGetProperties(BR_Envelope envelope)
(BR_Envelope envelope, Boolean activeOut, Boolean visibleOut, Boolean armedOut, Boolean inLaneOut, Int laneHeightOut, Int defaultShapeOut, Float minValueOut, Float maxValueOut, Float centerValueOut, Int typeOut, Boolean faderScalingOut, Int automationItemsOptionsOutOptional) = BR_EnvGetProperties(envelope, activeOut, visibleOut, armedOut, inLaneOut, laneHeightOut, defaultShapeOut, minValueOut, maxValueOut, centerValueOut, typeOut, faderScalingOut, automationItemsOptionsOutOptional)

[BR] Get envelope properties for the envelope object allocated with BR_EnvAlloc.

active: true if envelope is active
visible: true if envelope is visible
armed: true if envelope is armed
inLane: true if envelope has it's own envelope lane
laneHeight: envelope lane override height. 0 for none, otherwise size in pixels
defaultShape: default point shape: 0->Linear, 1->Square, 2->Slow start/end, 3->Fast start, 4->Fast end, 5->Bezier
minValue: minimum envelope value
maxValue: maximum envelope value
type: envelope type: 0->Volume, 1->Volume (Pre-FX), 2->Pan, 3->Pan (Pre-FX), 4->Width, 5->Width (Pre-FX), 6->Mute, 7->Pitch, 8->Playrate, 9->Tempo map, 10->Parameter
faderScaling: true if envelope uses fader scaling
automationItemsOptions: -1->project default, &1=0->don't attach to underl. env., &1->attach to underl. env. on right side, &2->attach to underl. env. on both sides, &4: bypass underl. env.

bool BR_EnvSetPoint(BR_Envelope* envelope, int id, double position, double value, int shape, bool selected, double bezier)
bool BR_EnvSetPoint(BR_Envelope envelope, int id, position, value, int shape, bool selected, bezier) (requires REAPER 6.24 or later)
bool extension_api("BR_EnvSetPoint", BR_Envelope envelope, int id, position, value, int shape, bool selected, bezier) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_EnvSetPoint(BR_Envelope envelope, integer id, number position, number value, integer shape, boolean selected, number bezier)
Boolean BR_EnvSetPoint(BR_Envelope envelope, Int id, Float position, Float value, Int shape, Boolean selected, Float bezier)

[BR] Set envelope point by id (zero-based) in the envelope object allocated with BR_EnvAlloc. To create point instead, pass id = -1. Note that if new point is inserted or existing point's time position is changed, points won't automatically get sorted. To do that, see BR_EnvSortPoints.
Returns true on success.

void BR_EnvSetProperties(BR_Envelope* envelope, bool active, bool visible, bool armed, bool inLane, int laneHeight, int defaultShape, bool faderScaling, int* automationItemsOptionsInOptional)
BR_EnvSetProperties(BR_Envelope envelope, bool active, bool visible, bool armed, bool inLane, int laneHeight, int defaultShape, bool faderScaling, optional int automationItemsOptionsIn) (requires REAPER 6.24 or later)
extension_api("BR_EnvSetProperties", BR_Envelope envelope, bool active, bool visible, bool armed, bool inLane, int laneHeight, int defaultShape, bool faderScaling, optional int automationItemsOptionsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.BR_EnvSetProperties(BR_Envelope envelope, boolean active, boolean visible, boolean armed, boolean inLane, integer laneHeight, integer defaultShape, boolean faderScaling, optional integer automationItemsOptionsIn)
(BR_Envelope envelope, Boolean active, Boolean visible, Boolean armed, Boolean inLane, Int laneHeight, Int defaultShape, Boolean faderScaling, Int automationItemsOptionsInOptional) = BR_EnvSetProperties(envelope, active, visible, armed, inLane, laneHeight, defaultShape, faderScaling, automationItemsOptionsInOptional)

[BR] Set envelope properties for the envelope object allocated with BR_EnvAlloc. For parameter description see BR_EnvGetProperties.
Setting automationItemsOptions requires REAPER 5.979+.

void BR_EnvSortPoints(BR_Envelope* envelope)
BR_EnvSortPoints(BR_Envelope envelope) (requires REAPER 6.24 or later)
extension_api("BR_EnvSortPoints", BR_Envelope envelope) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.BR_EnvSortPoints(BR_Envelope envelope)
BR_EnvSortPoints(BR_Envelope envelope)

[BR] Sort envelope points by position. The only reason to call this is if sorted points are explicitly needed after editing them with BR_EnvSetPoint. Note that you do not have to call this before doing BR_EnvFree since it does handle unsorted points too.

double BR_EnvValueAtPos(BR_Envelope* envelope, double position)
double BR_EnvValueAtPos(BR_Envelope envelope, position) (requires REAPER 6.24 or later)
double extension_api("BR_EnvValueAtPos", BR_Envelope envelope, position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.BR_EnvValueAtPos(BR_Envelope envelope, number position)
Float BR_EnvValueAtPos(BR_Envelope envelope, Float position)

[BR] Get envelope value at time position for the envelope object allocated with BR_EnvAlloc.

void BR_GetArrangeView(ReaProject* proj, double* startTimeOut, double* endTimeOut)
BR_GetArrangeView(ReaProject proj, &startTime, &endTime) (requires REAPER 6.24 or later)
extension_api("BR_GetArrangeView", ReaProject proj, &startTime, &endTime) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number startTime, number endTime = reaper.BR_GetArrangeView(ReaProject proj)
(ReaProject proj, Float startTimeOut, Float endTimeOut) = BR_GetArrangeView(proj, startTimeOut, endTimeOut)

[BR] Deprecated, see GetSet_ArrangeView2 (REAPER v5.12pre4+) -- Get start and end time position of arrange view. To set arrange view instead, see BR_SetArrangeView.

double BR_GetClosestGridDivision(double position)
double BR_GetClosestGridDivision(position) (requires REAPER 6.24 or later)
double extension_api("BR_GetClosestGridDivision", position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.BR_GetClosestGridDivision(number position)
Float BR_GetClosestGridDivision(Float position)

[BR] Get closest grid division to position. Note that this functions is different from SnapToGrid in two regards. SnapToGrid() needs snap enabled to work and this one works always. Secondly, grid divisions are different from grid lines because some grid lines may be hidden due to zoom level - this function ignores grid line visibility and always searches for the closest grid division at given position. For more grid division functions, see BR_GetNextGridDivision and BR_GetPrevGridDivision.

void BR_GetCurrentTheme(char* themePathOut, int themePathOut_sz, char* themeNameOut, int themeNameOut_sz)
BR_GetCurrentTheme(#themePath, #themeName) (requires REAPER 6.24 or later)
extension_api("BR_GetCurrentTheme", #themePath, #themeName) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string themePath, string themeName = reaper.BR_GetCurrentTheme()
(String themePathOut, Int themePathOut_sz, String themeNameOut, Int themeNameOut_sz) = BR_GetCurrentTheme(themePathOut, themePathOut_sz, themeNameOut, themeNameOut_sz)

[BR] Get current theme information. themePathOut is set to full theme path and themeNameOut is set to theme name excluding any path info and extension

MediaItem* BR_GetMediaItemByGUID(ReaProject* proj, const char* guidStringIn)
MediaItem BR_GetMediaItemByGUID(ReaProject proj, "guidStringIn") (requires REAPER 6.24 or later)
MediaItem extension_api("BR_GetMediaItemByGUID", ReaProject proj, "guidStringIn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaItem reaper.BR_GetMediaItemByGUID(ReaProject proj, string guidStringIn)
MediaItem BR_GetMediaItemByGUID(ReaProject proj, String guidStringIn)

[BR] Get media item from GUID string. Note that the GUID must be enclosed in braces {}. To get item's GUID as a string, see BR_GetMediaItemGUID.

void BR_GetMediaItemGUID(MediaItem* item, char* guidStringOut, int guidStringOut_sz)
BR_GetMediaItemGUID(MediaItem item, #guidString) (requires REAPER 6.24 or later)
extension_api("BR_GetMediaItemGUID", MediaItem item, #guidString) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string guidString = reaper.BR_GetMediaItemGUID(MediaItem item)
(MediaItem item, String guidStringOut, Int guidStringOut_sz) = BR_GetMediaItemGUID(item, guidStringOut, guidStringOut_sz)

[BR] Get media item GUID as a string (guidStringOut_sz should be at least 64). To get media item back from GUID string, see BR_GetMediaItemByGUID.

bool BR_GetMediaItemImageResource(MediaItem* item, char* imageOut, int imageOut_sz, int* imageFlagsOut)
bool BR_GetMediaItemImageResource(MediaItem item, #image, int &imageFlags) (requires REAPER 6.24 or later)
bool extension_api("BR_GetMediaItemImageResource", MediaItem item, #image, int &imageFlags) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string image, integer imageFlags = reaper.BR_GetMediaItemImageResource(MediaItem item)
(Boolean retval, MediaItem item, String imageOut, Int imageOut_sz, Int imageFlagsOut) = BR_GetMediaItemImageResource(item, imageOut, imageOut_sz, imageFlagsOut)

[BR] Get currently loaded image resource and its flags for a given item. Returns false if there is no image resource set. To set image resource, see BR_SetMediaItemImageResource.

void BR_GetMediaItemTakeGUID(MediaItem_Take* take, char* guidStringOut, int guidStringOut_sz)
BR_GetMediaItemTakeGUID(MediaItem_Take take, #guidString) (requires REAPER 6.24 or later)
extension_api("BR_GetMediaItemTakeGUID", MediaItem_Take take, #guidString) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string guidString = reaper.BR_GetMediaItemTakeGUID(MediaItem_Take take)
(MediaItem_Take take, String guidStringOut, Int guidStringOut_sz) = BR_GetMediaItemTakeGUID(take, guidStringOut, guidStringOut_sz)

[BR] Get media item take GUID as a string (guidStringOut_sz should be at least 64). To get take from GUID string, see SNM_GetMediaItemTakeByGUID.

bool BR_GetMediaSourceProperties(MediaItem_Take* take, bool* sectionOut, double* startOut, double* lengthOut, double* fadeOut, bool* reverseOut)
bool BR_GetMediaSourceProperties(MediaItem_Take take, bool &section, &start, &length, &fade, bool &reverse) (requires REAPER 6.24 or later)
bool extension_api("BR_GetMediaSourceProperties", MediaItem_Take take, bool &section, &start, &length, &fade, bool &reverse) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, boolean section, number start, number length, number fade, boolean reverse = reaper.BR_GetMediaSourceProperties(MediaItem_Take take)
(Boolean retval, MediaItem_Take take, Boolean sectionOut, Float startOut, Float lengthOut, Float fadeOut, Boolean reverseOut) = BR_GetMediaSourceProperties(take, sectionOut, startOut, lengthOut, fadeOut, reverseOut)

[BR] Get take media source properties as they appear in Item properties. Returns false if take can't have them (MIDI items etc.).
To set source properties, see BR_SetMediaSourceProperties.

MediaTrack* BR_GetMediaTrackByGUID(ReaProject* proj, const char* guidStringIn)
MediaTrack BR_GetMediaTrackByGUID(ReaProject proj, "guidStringIn") (requires REAPER 6.24 or later)
MediaTrack extension_api("BR_GetMediaTrackByGUID", ReaProject proj, "guidStringIn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaTrack reaper.BR_GetMediaTrackByGUID(ReaProject proj, string guidStringIn)
MediaTrack BR_GetMediaTrackByGUID(ReaProject proj, String guidStringIn)

[BR] Get media track from GUID string. Note that the GUID must be enclosed in braces {}. To get track's GUID as a string, see GetSetMediaTrackInfo_String.

int BR_GetMediaTrackFreezeCount(MediaTrack* track)
int BR_GetMediaTrackFreezeCount(MediaTrack track) (requires REAPER 6.24 or later)
int extension_api("BR_GetMediaTrackFreezeCount", MediaTrack track) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_GetMediaTrackFreezeCount(MediaTrack track)
Int BR_GetMediaTrackFreezeCount(MediaTrack track)

[BR] Get media track freeze count (if track isn't frozen at all, returns 0).

void BR_GetMediaTrackGUID(MediaTrack* track, char* guidStringOut, int guidStringOut_sz)
BR_GetMediaTrackGUID(MediaTrack track, #guidString) (requires REAPER 6.24 or later)
extension_api("BR_GetMediaTrackGUID", MediaTrack track, #guidString) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string guidString = reaper.BR_GetMediaTrackGUID(MediaTrack track)
(MediaTrack track, String guidStringOut, Int guidStringOut_sz) = BR_GetMediaTrackGUID(track, guidStringOut, guidStringOut_sz)

[BR] Deprecated, see GetSetMediaTrackInfo_String (v5.95+). Get media track GUID as a string (guidStringOut_sz should be at least 64). To get media track back from GUID string, see BR_GetMediaTrackByGUID.

void BR_GetMediaTrackLayouts(MediaTrack* track, char* mcpLayoutNameOut, int mcpLayoutNameOut_sz, char* tcpLayoutNameOut, int tcpLayoutNameOut_sz)
BR_GetMediaTrackLayouts(MediaTrack track, #mcpLayoutName, #tcpLayoutName) (requires REAPER 6.24 or later)
extension_api("BR_GetMediaTrackLayouts", MediaTrack track, #mcpLayoutName, #tcpLayoutName) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string mcpLayoutName, string tcpLayoutName = reaper.BR_GetMediaTrackLayouts(MediaTrack track)
(MediaTrack track, String mcpLayoutNameOut, Int mcpLayoutNameOut_sz, String tcpLayoutNameOut, Int tcpLayoutNameOut_sz) = BR_GetMediaTrackLayouts(track, mcpLayoutNameOut, mcpLayoutNameOut_sz, tcpLayoutNameOut, tcpLayoutNameOut_sz)

[BR] Deprecated, see GetSetMediaTrackInfo (REAPER v5.02+). Get media track layouts for MCP and TCP. Empty string ("") means that layout is set to the default layout. To set media track layouts, see BR_SetMediaTrackLayouts.

TrackEnvelope* BR_GetMediaTrackSendInfo_Envelope(MediaTrack* track, int category, int sendidx, int envelopeType)
TrackEnvelope BR_GetMediaTrackSendInfo_Envelope(MediaTrack track, int category, int sendidx, int envelopeType) (requires REAPER 6.24 or later)
TrackEnvelope extension_api("BR_GetMediaTrackSendInfo_Envelope", MediaTrack track, int category, int sendidx, int envelopeType) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
TrackEnvelope reaper.BR_GetMediaTrackSendInfo_Envelope(MediaTrack track, integer category, integer sendidx, integer envelopeType)
TrackEnvelope BR_GetMediaTrackSendInfo_Envelope(MediaTrack track, Int category, Int sendidx, Int envelopeType)

[BR] Get track envelope for send/receive/hardware output.

category is <0 for receives, 0=sends, >0 for hardware outputs
sendidx is zero-based (see GetTrackNumSends to count track sends/receives/hardware outputs)
envelopeType determines which envelope is returned (0=volume, 1=pan, 2=mute)

Note: To get or set other send attributes, see BR_GetSetTrackSendInfo and BR_GetMediaTrackSendInfo_Track.

MediaTrack* BR_GetMediaTrackSendInfo_Track(MediaTrack* track, int category, int sendidx, int trackType)
MediaTrack BR_GetMediaTrackSendInfo_Track(MediaTrack track, int category, int sendidx, int trackType) (requires REAPER 6.24 or later)
MediaTrack extension_api("BR_GetMediaTrackSendInfo_Track", MediaTrack track, int category, int sendidx, int trackType) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaTrack reaper.BR_GetMediaTrackSendInfo_Track(MediaTrack track, integer category, integer sendidx, integer trackType)
MediaTrack BR_GetMediaTrackSendInfo_Track(MediaTrack track, Int category, Int sendidx, Int trackType)

[BR] Get source or destination media track for send/receive.

category is <0 for receives, 0=sends
sendidx is zero-based (see GetTrackNumSends to count track sends/receives)
trackType determines which track is returned (0=source track, 1=destination track)

Note: To get or set other send attributes, see BR_GetSetTrackSendInfo and BR_GetMediaTrackSendInfo_Envelope.

double BR_GetMidiSourceLenPPQ(MediaItem_Take* take)
double BR_GetMidiSourceLenPPQ(MediaItem_Take take) (requires REAPER 6.24 or later)
double extension_api("BR_GetMidiSourceLenPPQ", MediaItem_Take take) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.BR_GetMidiSourceLenPPQ(MediaItem_Take take)
Float BR_GetMidiSourceLenPPQ(MediaItem_Take take)

[BR] Get MIDI take source length in PPQ. In case the take isn't MIDI, return value will be -1.

bool BR_GetMidiTakePoolGUID(MediaItem_Take* take, char* guidStringOut, int guidStringOut_sz)
bool BR_GetMidiTakePoolGUID(MediaItem_Take take, #guidString) (requires REAPER 6.24 or later)
bool extension_api("BR_GetMidiTakePoolGUID", MediaItem_Take take, #guidString) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string guidString = reaper.BR_GetMidiTakePoolGUID(MediaItem_Take take)
(Boolean retval, MediaItem_Take take, String guidStringOut, Int guidStringOut_sz) = BR_GetMidiTakePoolGUID(take, guidStringOut, guidStringOut_sz)

[BR] Get MIDI take pool GUID as a string (guidStringOut_sz should be at least 64). Returns true if take is pooled.

bool BR_GetMidiTakeTempoInfo(MediaItem_Take* take, bool* ignoreProjTempoOut, double* bpmOut, int* numOut, int* denOut)
bool BR_GetMidiTakeTempoInfo(MediaItem_Take take, bool &ignoreProjTempo, &bpm, int &num, int &den) (requires REAPER 6.24 or later)
bool extension_api("BR_GetMidiTakeTempoInfo", MediaItem_Take take, bool &ignoreProjTempo, &bpm, int &num, int &den) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, boolean ignoreProjTempo, number bpm, integer num, integer den = reaper.BR_GetMidiTakeTempoInfo(MediaItem_Take take)
(Boolean retval, MediaItem_Take take, Boolean ignoreProjTempoOut, Float bpmOut, Int numOut, Int denOut) = BR_GetMidiTakeTempoInfo(take, ignoreProjTempoOut, bpmOut, numOut, denOut)

[BR] Get "ignore project tempo" information for MIDI take. Returns true if take can ignore project tempo (no matter if it's actually ignored), otherwise false.

void BR_GetMouseCursorContext(char* windowOut, int windowOut_sz, char* segmentOut, int segmentOut_sz, char* detailsOut, int detailsOut_sz)
BR_GetMouseCursorContext(#window, #segment, #details) (requires REAPER 6.24 or later)
extension_api("BR_GetMouseCursorContext", #window, #segment, #details) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string window, string segment, string details = reaper.BR_GetMouseCursorContext()
(String windowOut, Int windowOut_sz, String segmentOut, Int segmentOut_sz, String detailsOut, Int detailsOut_sz) = BR_GetMouseCursorContext(windowOut, windowOut_sz, segmentOut, segmentOut_sz, detailsOut, detailsOut_sz)

[BR] Get mouse cursor context. Each parameter returns information in a form of string as specified in the table below.

To get more info on stuff that was found under mouse cursor see BR_GetMouseCursorContext_Envelope, BR_GetMouseCursorContext_Item, BR_GetMouseCursorContext_MIDI, BR_GetMouseCursorContext_Position, BR_GetMouseCursorContext_Take, BR_GetMouseCursorContext_Track

Window Segment Details
unknown "" ""
ruler region_lane ""
marker_lane ""
tempo_lane ""
timeline ""
transport "" ""
tcp track ""
envelope ""
empty ""
mcp track ""
empty ""
arrange track empty,
item, item_stretch_marker,
env_point, env_segment
envelope empty, env_point, env_segment
empty ""
midi_editor unknown ""
ruler ""
piano ""
notes ""
cc_lane cc_selector, cc_lane
TrackEnvelope* BR_GetMouseCursorContext_Envelope(bool* takeEnvelopeOut)
TrackEnvelope BR_GetMouseCursorContext_Envelope(bool &takeEnvelope) (requires REAPER 6.24 or later)
TrackEnvelope extension_api("BR_GetMouseCursorContext_Envelope", bool &takeEnvelope) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
TrackEnvelope retval, boolean takeEnvelope = reaper.BR_GetMouseCursorContext_Envelope()
(TrackEnvelope retval, Boolean takeEnvelopeOut) = BR_GetMouseCursorContext_Envelope(takeEnvelopeOut)

[BR] Returns envelope that was captured with the last call to BR_GetMouseCursorContext. In case the envelope belongs to take, takeEnvelope will be true.

MediaItem* BR_GetMouseCursorContext_Item()
MediaItem BR_GetMouseCursorContext_Item() (requires REAPER 6.24 or later)
MediaItem extension_api("BR_GetMouseCursorContext_Item") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaItem reaper.BR_GetMouseCursorContext_Item()
MediaItem BR_GetMouseCursorContext_Item()

[BR] Returns item under mouse cursor that was captured with the last call to BR_GetMouseCursorContext. Note that the function will return item even if mouse cursor is over some other track lane element like stretch marker or envelope. This enables for easier identification of items when you want to ignore elements within the item.

void* BR_GetMouseCursorContext_MIDI(bool* inlineEditorOut, int* noteRowOut, int* ccLaneOut, int* ccLaneValOut, int* ccLaneIdOut)
void* BR_GetMouseCursorContext_MIDI(bool &inlineEditor, int &noteRow, int &ccLane, int &ccLaneVal, int &ccLaneId) (requires REAPER 6.24 or later)
void* extension_api("BR_GetMouseCursorContext_MIDI", bool &inlineEditor, int &noteRow, int &ccLane, int &ccLaneVal, int &ccLaneId) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier retval, boolean inlineEditor, integer noteRow, integer ccLane, integer ccLaneVal, integer ccLaneId = reaper.BR_GetMouseCursorContext_MIDI()
(void retval, Boolean inlineEditorOut, Int noteRowOut, Int ccLaneOut, Int ccLaneValOut, Int ccLaneIdOut) = BR_GetMouseCursorContext_MIDI(inlineEditorOut, noteRowOut, ccLaneOut, ccLaneValOut, ccLaneIdOut)

[BR] Returns midi editor under mouse cursor that was captured with the last call to BR_GetMouseCursorContext.

inlineEditor: if mouse was captured in inline MIDI editor, this will be true (consequentially, returned MIDI editor will be NULL)
noteRow: note row or piano key under mouse cursor (0-127)
ccLane: CC lane under mouse cursor (CC0-127=CC, 0x100|(0-31)=14-bit CC, 0x200=velocity, 0x201=pitch, 0x202=program, 0x203=channel pressure, 0x204=bank/program select, 0x205=text, 0x206=sysex, 0x207=off velocity, 0x208=notation events)
ccLaneVal: value in CC lane under mouse cursor (0-127 or 0-16383)
ccLaneId: lane position, counting from the top (0 based)

Note: due to API limitations, if mouse is over inline MIDI editor with some note rows hidden, noteRow will be -1

double BR_GetMouseCursorContext_Position()
double BR_GetMouseCursorContext_Position() (requires REAPER 6.24 or later)
double extension_api("BR_GetMouseCursorContext_Position") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.BR_GetMouseCursorContext_Position()
Float BR_GetMouseCursorContext_Position()

[BR] Returns project time position in arrange/ruler/midi editor that was captured with the last call to BR_GetMouseCursorContext.

int BR_GetMouseCursorContext_StretchMarker()
int BR_GetMouseCursorContext_StretchMarker() (requires REAPER 6.24 or later)
int extension_api("BR_GetMouseCursorContext_StretchMarker") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_GetMouseCursorContext_StretchMarker()
Int BR_GetMouseCursorContext_StretchMarker()

[BR] Returns id of a stretch marker under mouse cursor that was captured with the last call to BR_GetMouseCursorContext.

MediaItem_Take* BR_GetMouseCursorContext_Take()
MediaItem_Take BR_GetMouseCursorContext_Take() (requires REAPER 6.24 or later)
MediaItem_Take extension_api("BR_GetMouseCursorContext_Take") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaItem_Take reaper.BR_GetMouseCursorContext_Take()
MediaItem_Take BR_GetMouseCursorContext_Take()

[BR] Returns take under mouse cursor that was captured with the last call to BR_GetMouseCursorContext.

MediaTrack* BR_GetMouseCursorContext_Track()
MediaTrack BR_GetMouseCursorContext_Track() (requires REAPER 6.24 or later)
MediaTrack extension_api("BR_GetMouseCursorContext_Track") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaTrack reaper.BR_GetMouseCursorContext_Track()
MediaTrack BR_GetMouseCursorContext_Track()

[BR] Returns track under mouse cursor that was captured with the last call to BR_GetMouseCursorContext.

double BR_GetNextGridDivision(double position)
double BR_GetNextGridDivision(position) (requires REAPER 6.24 or later)
double extension_api("BR_GetNextGridDivision", position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.BR_GetNextGridDivision(number position)
Float BR_GetNextGridDivision(Float position)

[BR] Get next grid division after the time position. For more grid divisions function, see BR_GetClosestGridDivision and BR_GetPrevGridDivision.

double BR_GetPrevGridDivision(double position)
double BR_GetPrevGridDivision(position) (requires REAPER 6.24 or later)
double extension_api("BR_GetPrevGridDivision", position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.BR_GetPrevGridDivision(number position)
Float BR_GetPrevGridDivision(Float position)

[BR] Get previous grid division before the time position. For more grid division functions, see BR_GetClosestGridDivision and BR_GetNextGridDivision.

double BR_GetSetTrackSendInfo(MediaTrack* track, int category, int sendidx, const char* parmname, bool setNewValue, double newValue)
double BR_GetSetTrackSendInfo(MediaTrack track, int category, int sendidx, "parmname", bool setNewValue, newValue) (requires REAPER 6.24 or later)
double extension_api("BR_GetSetTrackSendInfo", MediaTrack track, int category, int sendidx, "parmname", bool setNewValue, newValue) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.BR_GetSetTrackSendInfo(MediaTrack track, integer category, integer sendidx, string parmname, boolean setNewValue, number newValue)
Float BR_GetSetTrackSendInfo(MediaTrack track, Int category, Int sendidx, String parmname, Boolean setNewValue, Float newValue)

[BR] Get or set send attributes.

category is <0 for receives, 0=sends, >0 for hardware outputs
sendidx is zero-based (see GetTrackNumSends to count track sends/receives/hardware outputs)
To set attribute, pass setNewValue as true

List of possible parameters:
B_MUTE : send mute state (1.0 if muted, otherwise 0.0)
B_PHASE : send phase state (1.0 if phase is inverted, otherwise 0.0)
B_MONO : send mono state (1.0 if send is set to mono, otherwise 0.0)
D_VOL : send volume (1.0=+0dB etc...)
D_PAN : send pan (-1.0=100%L, 0=center, 1.0=100%R)
D_PANLAW : send pan law (1.0=+0.0db, 0.5=-6dB, -1.0=project default etc...)
I_SENDMODE : send mode (0=post-fader, 1=pre-fx, 2=post-fx(deprecated), 3=post-fx)
I_SRCCHAN : audio source starting channel index or -1 if audio send is disabled (&1024=mono...note that in that case, when reading index, you should do (index XOR 1024) to get starting channel index)
I_DSTCHAN : audio destination starting channel index (&1024=mono (and in case of hardware output &512=rearoute)...note that in that case, when reading index, you should do (index XOR (1024 OR 512)) to get starting channel index)
I_MIDI_SRCCHAN : source MIDI channel, -1 if MIDI send is disabled (0=all, 1-16)
I_MIDI_DSTCHAN : destination MIDI channel, -1 if MIDI send is disabled (0=original, 1-16)
I_MIDI_SRCBUS : source MIDI bus, -1 if MIDI send is disabled (0=all, otherwise bus index)
I_MIDI_DSTBUS : receive MIDI bus, -1 if MIDI send is disabled (0=all, otherwise bus index)
I_MIDI_LINK_VOLPAN : link volume/pan controls to MIDI

Note: To get or set other send attributes, see BR_GetMediaTrackSendInfo_Envelope and BR_GetMediaTrackSendInfo_Track.

int BR_GetTakeFXCount(MediaItem_Take* take)
int BR_GetTakeFXCount(MediaItem_Take take) (requires REAPER 6.24 or later)
int extension_api("BR_GetTakeFXCount", MediaItem_Take take) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_GetTakeFXCount(MediaItem_Take take)
Int BR_GetTakeFXCount(MediaItem_Take take)

[BR] Returns FX count for supplied take

bool BR_IsMidiOpenInInlineEditor(MediaItem_Take* take)
bool BR_IsMidiOpenInInlineEditor(MediaItem_Take take) (requires REAPER 6.24 or later)
bool extension_api("BR_IsMidiOpenInInlineEditor", MediaItem_Take take) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_IsMidiOpenInInlineEditor(MediaItem_Take take)
Boolean BR_IsMidiOpenInInlineEditor(MediaItem_Take take)

[SWS] Check if take has MIDI inline editor open and returns true or false.

bool BR_IsTakeMidi(MediaItem_Take* take, bool* inProjectMidiOut)
bool BR_IsTakeMidi(MediaItem_Take take, bool &inProjectMidi) (requires REAPER 6.24 or later)
bool extension_api("BR_IsTakeMidi", MediaItem_Take take, bool &inProjectMidi) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, boolean inProjectMidi = reaper.BR_IsTakeMidi(MediaItem_Take take)
(Boolean retval, MediaItem_Take take, Boolean inProjectMidiOut) = BR_IsTakeMidi(take, inProjectMidiOut)

[BR] Check if take is MIDI take, in case MIDI take is in-project MIDI source data, inProjectMidiOut will be true, otherwise false.

MediaItem* BR_ItemAtMouseCursor(double* positionOut)
MediaItem BR_ItemAtMouseCursor(&position) (requires REAPER 6.24 or later)
MediaItem extension_api("BR_ItemAtMouseCursor", &position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaItem retval, number position = reaper.BR_ItemAtMouseCursor()
(MediaItem retval, Float positionOut) = BR_ItemAtMouseCursor(positionOut)

[BR] Get media item under mouse cursor. Position is mouse cursor position in arrange.

bool BR_MIDI_CCLaneRemove(void* midiEditor, int laneId)
bool BR_MIDI_CCLaneRemove(void* midiEditor, int laneId) (requires REAPER 6.24 or later)
bool extension_api("BR_MIDI_CCLaneRemove", void* midiEditor, int laneId) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_MIDI_CCLaneRemove(identifier midiEditor, integer laneId)
Boolean BR_MIDI_CCLaneRemove(void midiEditor, Int laneId)

[BR] Remove CC lane in midi editor. Top visible CC lane is laneId 0. Returns true on success

bool BR_MIDI_CCLaneReplace(void* midiEditor, int laneId, int newCC)
bool BR_MIDI_CCLaneReplace(void* midiEditor, int laneId, int newCC) (requires REAPER 6.24 or later)
bool extension_api("BR_MIDI_CCLaneReplace", void* midiEditor, int laneId, int newCC) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_MIDI_CCLaneReplace(identifier midiEditor, integer laneId, integer newCC)
Boolean BR_MIDI_CCLaneReplace(void midiEditor, Int laneId, Int newCC)

[BR] Replace CC lane in midi editor. Top visible CC lane is laneId 0. Returns true on success.
Valid CC lanes: CC0-127=CC, 0x100|(0-31)=14-bit CC, 0x200=velocity, 0x201=pitch, 0x202=program, 0x203=channel pressure, 0x204=bank/program select, 0x205=text, 0x206=sysex, 0x207

double BR_PositionAtMouseCursor(bool checkRuler)
double BR_PositionAtMouseCursor(bool checkRuler) (requires REAPER 6.24 or later)
double extension_api("BR_PositionAtMouseCursor", bool checkRuler) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.BR_PositionAtMouseCursor(boolean checkRuler)
Float BR_PositionAtMouseCursor(Boolean checkRuler)

[BR] Get position at mouse cursor. To check ruler along with arrange, pass checkRuler=true. Returns -1 if cursor is not over arrange/ruler.

void BR_SetArrangeView(ReaProject* proj, double startTime, double endTime)
BR_SetArrangeView(ReaProject proj, startTime, endTime) (requires REAPER 6.24 or later)
extension_api("BR_SetArrangeView", ReaProject proj, startTime, endTime) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.BR_SetArrangeView(ReaProject proj, number startTime, number endTime)
BR_SetArrangeView(ReaProject proj, Float startTime, Float endTime)

[BR] Deprecated, see GetSet_ArrangeView2 (REAPER v5.12pre4+) -- Set start and end time position of arrange view. To get arrange view instead, see BR_GetArrangeView.

bool BR_SetItemEdges(MediaItem* item, double startTime, double endTime)
bool BR_SetItemEdges(MediaItem item, startTime, endTime) (requires REAPER 6.24 or later)
bool extension_api("BR_SetItemEdges", MediaItem item, startTime, endTime) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_SetItemEdges(MediaItem item, number startTime, number endTime)
Boolean BR_SetItemEdges(MediaItem item, Float startTime, Float endTime)

[BR] Set item start and end edges' position - returns true in case of any changes

void BR_SetMediaItemImageResource(MediaItem* item, const char* imageIn, int imageFlags)
BR_SetMediaItemImageResource(MediaItem item, "imageIn", int imageFlags) (requires REAPER 6.24 or later)
extension_api("BR_SetMediaItemImageResource", MediaItem item, "imageIn", int imageFlags) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.BR_SetMediaItemImageResource(MediaItem item, string imageIn, integer imageFlags)
BR_SetMediaItemImageResource(MediaItem item, String imageIn, Int imageFlags)

[BR] Set image resource and its flags for a given item. To clear current image resource, pass imageIn as "".
imageFlags: &1=0: don't display image, &1: center / tile, &3: stretch, &5: full height (REAPER 5.974+).
Can also be used to display existing text in empty items unstretched (pass imageIn = "", imageFlags = 0) or stretched (pass imageIn = "". imageFlags = 3).
To get image resource, see BR_GetMediaItemImageResource.

bool BR_SetMediaSourceProperties(MediaItem_Take* take, bool section, double start, double length, double fade, bool reverse)
bool BR_SetMediaSourceProperties(MediaItem_Take take, bool section, start, length, fade, bool reverse) (requires REAPER 6.24 or later)
bool extension_api("BR_SetMediaSourceProperties", MediaItem_Take take, bool section, start, length, fade, bool reverse) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_SetMediaSourceProperties(MediaItem_Take take, boolean section, number start, number length, number fade, boolean reverse)
Boolean BR_SetMediaSourceProperties(MediaItem_Take take, Boolean section, Float start, Float length, Float fade, Boolean reverse)

[BR] Set take media source properties. Returns false if take can't have them (MIDI items etc.). Section parameters have to be valid only when passing section=true.
To get source properties, see BR_GetMediaSourceProperties.

bool BR_SetMediaTrackLayouts(MediaTrack* track, const char* mcpLayoutNameIn, const char* tcpLayoutNameIn)
bool BR_SetMediaTrackLayouts(MediaTrack track, "mcpLayoutNameIn", "tcpLayoutNameIn") (requires REAPER 6.24 or later)
bool extension_api("BR_SetMediaTrackLayouts", MediaTrack track, "mcpLayoutNameIn", "tcpLayoutNameIn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_SetMediaTrackLayouts(MediaTrack track, string mcpLayoutNameIn, string tcpLayoutNameIn)
Boolean BR_SetMediaTrackLayouts(MediaTrack track, String mcpLayoutNameIn, String tcpLayoutNameIn)

[BR] Deprecated, see GetSetMediaTrackInfo (REAPER v5.02+). Set media track layouts for MCP and TCP. To set default layout, pass empty string ("") as layout name. In case layouts were successfully set, returns true (if layouts are already set to supplied layout names, it will return false since no changes were made).
To get media track layouts, see BR_GetMediaTrackLayouts.

bool BR_SetMidiTakeTempoInfo(MediaItem_Take* take, bool ignoreProjTempo, double bpm, int num, int den)
bool BR_SetMidiTakeTempoInfo(MediaItem_Take take, bool ignoreProjTempo, bpm, int num, int den) (requires REAPER 6.24 or later)
bool extension_api("BR_SetMidiTakeTempoInfo", MediaItem_Take take, bool ignoreProjTempo, bpm, int num, int den) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_SetMidiTakeTempoInfo(MediaItem_Take take, boolean ignoreProjTempo, number bpm, integer num, integer den)
Boolean BR_SetMidiTakeTempoInfo(MediaItem_Take take, Boolean ignoreProjTempo, Float bpm, Int num, Int den)

[BR] Set "ignore project tempo" information for MIDI take. Returns true in case the take was successfully updated.

bool BR_SetTakeSourceFromFile(MediaItem_Take* take, const char* filenameIn, bool inProjectData)
bool BR_SetTakeSourceFromFile(MediaItem_Take take, "filenameIn", bool inProjectData) (requires REAPER 6.24 or later)
bool extension_api("BR_SetTakeSourceFromFile", MediaItem_Take take, "filenameIn", bool inProjectData) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_SetTakeSourceFromFile(MediaItem_Take take, string filenameIn, boolean inProjectData)
Boolean BR_SetTakeSourceFromFile(MediaItem_Take take, String filenameIn, Boolean inProjectData)

[BR] Set new take source from file. To import MIDI file as in-project source data pass inProjectData=true. Returns false if failed.
Any take source properties from the previous source will be lost - to preserve them, see BR_SetTakeSourceFromFile2.
Note: To set source from existing take, see SNM_GetSetSourceState2.

bool BR_SetTakeSourceFromFile2(MediaItem_Take* take, const char* filenameIn, bool inProjectData, bool keepSourceProperties)
bool BR_SetTakeSourceFromFile2(MediaItem_Take take, "filenameIn", bool inProjectData, bool keepSourceProperties) (requires REAPER 6.24 or later)
bool extension_api("BR_SetTakeSourceFromFile2", MediaItem_Take take, "filenameIn", bool inProjectData, bool keepSourceProperties) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_SetTakeSourceFromFile2(MediaItem_Take take, string filenameIn, boolean inProjectData, boolean keepSourceProperties)
Boolean BR_SetTakeSourceFromFile2(MediaItem_Take take, String filenameIn, Boolean inProjectData, Boolean keepSourceProperties)

[BR] Differs from BR_SetTakeSourceFromFile only that it can also preserve existing take media source properties.

MediaItem_Take* BR_TakeAtMouseCursor(double* positionOut)
MediaItem_Take BR_TakeAtMouseCursor(&position) (requires REAPER 6.24 or later)
MediaItem_Take extension_api("BR_TakeAtMouseCursor", &position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaItem_Take retval, number position = reaper.BR_TakeAtMouseCursor()
(MediaItem_Take retval, Float positionOut) = BR_TakeAtMouseCursor(positionOut)

[BR] Get take under mouse cursor. Position is mouse cursor position in arrange.

MediaTrack* BR_TrackAtMouseCursor(int* contextOut, double* positionOut)
MediaTrack BR_TrackAtMouseCursor(int &context, &position) (requires REAPER 6.24 or later)
MediaTrack extension_api("BR_TrackAtMouseCursor", int &context, &position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaTrack retval, integer context, number position = reaper.BR_TrackAtMouseCursor()
(MediaTrack retval, Int contextOut, Float positionOut) = BR_TrackAtMouseCursor(contextOut, positionOut)

[BR] Get track under mouse cursor.
Context signifies where the track was found: 0 = TCP, 1 = MCP, 2 = Arrange.
Position will hold mouse cursor position in arrange if applicable.

bool BR_TrackFX_GetFXModuleName(MediaTrack* track, int fx, char* nameOut, int nameOut_sz)
bool BR_TrackFX_GetFXModuleName(MediaTrack track, int fx, #name) (requires REAPER 6.24 or later)
bool extension_api("BR_TrackFX_GetFXModuleName", MediaTrack track, int fx, #name) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string name = reaper.BR_TrackFX_GetFXModuleName(MediaTrack track, integer fx)
(Boolean retval, MediaTrack track, Int fx, String nameOut, Int nameOut_sz) = BR_TrackFX_GetFXModuleName(track, fx, nameOut, nameOut_sz)

[BR] Deprecated, see TrackFX_GetNamedConfigParm/'fx_ident' (v6.37+). Get the exact name (like effect.dll, effect.vst3, etc...) of an FX.

int BR_Win32_CB_FindString(void* comboBoxHwnd, int startId, const char* string)
int BR_Win32_CB_FindString(void* comboBoxHwnd, int startId, "string") (requires REAPER 6.24 or later)
int extension_api("BR_Win32_CB_FindString", void* comboBoxHwnd, int startId, "string") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_CB_FindString(identifier comboBoxHwnd, integer startId, string string)
Int BR_Win32_CB_FindString(void comboBoxHwnd, Int startId, String string)

[BR] Equivalent to win32 API ComboBox_FindString().

int BR_Win32_CB_FindStringExact(void* comboBoxHwnd, int startId, const char* string)
int BR_Win32_CB_FindStringExact(void* comboBoxHwnd, int startId, "string") (requires REAPER 6.24 or later)
int extension_api("BR_Win32_CB_FindStringExact", void* comboBoxHwnd, int startId, "string") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_CB_FindStringExact(identifier comboBoxHwnd, integer startId, string string)
Int BR_Win32_CB_FindStringExact(void comboBoxHwnd, Int startId, String string)

[BR] Equivalent to win32 API ComboBox_FindStringExact().

void BR_Win32_ClientToScreen(void* hwnd, int xIn, int yIn, int* xOut, int* yOut)
BR_Win32_ClientToScreen(void* hwnd, int xIn, int yIn, int &x, int &y) (requires REAPER 6.24 or later)
extension_api("BR_Win32_ClientToScreen", void* hwnd, int xIn, int yIn, int &x, int &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer x, integer y = reaper.BR_Win32_ClientToScreen(identifier hwnd, integer xIn, integer yIn)
(void hwnd, Int xIn, Int yIn, Int xOut, Int yOut) = BR_Win32_ClientToScreen(hwnd, xIn, yIn, xOut, yOut)

[BR] Equivalent to win32 API ClientToScreen().

void* BR_Win32_FindWindowEx(const char* hwndParent, const char* hwndChildAfter, const char* className, const char* windowName, bool searchClass, bool searchName)
void* BR_Win32_FindWindowEx("hwndParent", "hwndChildAfter", "className", "windowName", bool searchClass, bool searchName) (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_FindWindowEx", "hwndParent", "hwndChildAfter", "className", "windowName", bool searchClass, bool searchName) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_FindWindowEx(string hwndParent, string hwndChildAfter, string className, string windowName, boolean searchClass, boolean searchName)
void BR_Win32_FindWindowEx(String hwndParent, String hwndChildAfter, String className, String windowName, Boolean searchClass, Boolean searchName)

[BR] Equivalent to win32 API FindWindowEx(). Since ReaScript doesn't allow passing NULL (None in Python, nil in Lua etc...) parameters, to search by supplied class or name set searchClass and searchName accordingly. HWND parameters should be passed as either "0" to signify NULL or as string obtained from BR_Win32_HwndToString.

int BR_Win32_GET_X_LPARAM(int lParam)
int BR_Win32_GET_X_LPARAM(int lParam) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_GET_X_LPARAM", int lParam) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_GET_X_LPARAM(integer lParam)
Int BR_Win32_GET_X_LPARAM(Int lParam)

[BR] Equivalent to win32 API GET_X_LPARAM().

int BR_Win32_GET_Y_LPARAM(int lParam)
int BR_Win32_GET_Y_LPARAM(int lParam) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_GET_Y_LPARAM", int lParam) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_GET_Y_LPARAM(integer lParam)
Int BR_Win32_GET_Y_LPARAM(Int lParam)

[BR] Equivalent to win32 API GET_Y_LPARAM().

int BR_Win32_GetConstant(const char* constantName)
int BR_Win32_GetConstant("constantName") (requires REAPER 6.24 or later)
int extension_api("BR_Win32_GetConstant", "constantName") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_GetConstant(string constantName)
Int BR_Win32_GetConstant(String constantName)

[BR] Returns various constants needed for BR_Win32 functions.
Supported constants are:
CB_ERR, CB_GETCOUNT, CB_GETCURSEL, CB_SETCURSEL
EM_SETSEL
GW_CHILD, GW_HWNDFIRST, GW_HWNDLAST, GW_HWNDNEXT, GW_HWNDPREV, GW_OWNER
GWL_STYLE
SW_HIDE, SW_MAXIMIZE, SW_SHOW, SW_SHOWMINIMIZED, SW_SHOWNA, SW_SHOWNOACTIVATE, SW_SHOWNORMAL
SWP_FRAMECHANGED, SWP_FRAMECHANGED, SWP_NOMOVE, SWP_NOOWNERZORDER, SWP_NOSIZE, SWP_NOZORDER
VK_DOWN, VK_UP
WM_CLOSE, WM_KEYDOWN
WS_MAXIMIZE, WS_OVERLAPPEDWINDOW

bool BR_Win32_GetCursorPos(int* xOut, int* yOut)
bool BR_Win32_GetCursorPos(int &x, int &y) (requires REAPER 6.24 or later)
bool extension_api("BR_Win32_GetCursorPos", int &x, int &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer x, integer y = reaper.BR_Win32_GetCursorPos()
(Boolean retval, Int xOut, Int yOut) = BR_Win32_GetCursorPos(xOut, yOut)

[BR] Equivalent to win32 API GetCursorPos().

void* BR_Win32_GetFocus()
void* BR_Win32_GetFocus() (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_GetFocus") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_GetFocus()
void BR_Win32_GetFocus()

[BR] Equivalent to win32 API GetFocus().

void* BR_Win32_GetForegroundWindow()
void* BR_Win32_GetForegroundWindow() (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_GetForegroundWindow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_GetForegroundWindow()
void BR_Win32_GetForegroundWindow()

[BR] Equivalent to win32 API GetForegroundWindow().

void* BR_Win32_GetMainHwnd()
void* BR_Win32_GetMainHwnd() (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_GetMainHwnd") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_GetMainHwnd()
void BR_Win32_GetMainHwnd()

[BR] Alternative to GetMainHwnd. REAPER seems to have problems with extensions using HWND type for exported functions so all BR_Win32 functions use void* instead of HWND type

void* BR_Win32_GetMixerHwnd(bool* isDockedOut)
void* BR_Win32_GetMixerHwnd(bool &isDocked) (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_GetMixerHwnd", bool &isDocked) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier retval, boolean isDocked = reaper.BR_Win32_GetMixerHwnd()
(void retval, Boolean isDockedOut) = BR_Win32_GetMixerHwnd(isDockedOut)

[BR] Get mixer window HWND. isDockedOut will be set to true if mixer is docked

void BR_Win32_GetMonitorRectFromRect(bool workingAreaOnly, int leftIn, int topIn, int rightIn, int bottomIn, int* leftOut, int* topOut, int* rightOut, int* bottomOut)
BR_Win32_GetMonitorRectFromRect(bool workingAreaOnly, int leftIn, int topIn, int rightIn, int bottomIn, int &left, int &top, int &right, int &bottom) (requires REAPER 6.24 or later)
extension_api("BR_Win32_GetMonitorRectFromRect", bool workingAreaOnly, int leftIn, int topIn, int rightIn, int bottomIn, int &left, int &top, int &right, int &bottom) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer left, integer top, integer right, integer bottom = reaper.BR_Win32_GetMonitorRectFromRect(boolean workingAreaOnly, integer leftIn, integer topIn, integer rightIn, integer bottomIn)
(Boolean workingAreaOnly, Int leftIn, Int topIn, Int rightIn, Int bottomIn, Int leftOut, Int topOut, Int rightOut, Int bottomOut) = BR_Win32_GetMonitorRectFromRect(workingAreaOnly, leftIn, topIn, rightIn, bottomIn, leftOut, topOut, rightOut, bottomOut)

[BR] Get coordinates for screen which is nearest to supplied coordinates. Pass workingAreaOnly as true to get screen coordinates excluding taskbar (or menu bar on OSX).

void* BR_Win32_GetParent(void* hwnd)
void* BR_Win32_GetParent(void* hwnd) (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_GetParent", void* hwnd) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_GetParent(identifier hwnd)
void BR_Win32_GetParent(void hwnd)

[BR] Equivalent to win32 API GetParent().

int BR_Win32_GetPrivateProfileString(const char* sectionName, const char* keyName, const char* defaultString, const char* filePath, char* stringOut, int stringOut_sz)
int BR_Win32_GetPrivateProfileString("sectionName", "keyName", "defaultString", "filePath", #string) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_GetPrivateProfileString", "sectionName", "keyName", "defaultString", "filePath", #string) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string string = reaper.BR_Win32_GetPrivateProfileString(string sectionName, string keyName, string defaultString, string filePath)
(Int retval, String sectionName, String keyName, String defaultString, String filePath, String stringOut, Int stringOut_sz) = BR_Win32_GetPrivateProfileString(sectionName, keyName, defaultString, filePath, stringOut, stringOut_sz)

[BR] Equivalent to win32 API GetPrivateProfileString(). For example, you can use this to get values from REAPER.ini.

void* BR_Win32_GetWindow(void* hwnd, int cmd)
void* BR_Win32_GetWindow(void* hwnd, int cmd) (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_GetWindow", void* hwnd, int cmd) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_GetWindow(identifier hwnd, integer cmd)
void BR_Win32_GetWindow(void hwnd, Int cmd)

[BR] Equivalent to win32 API GetWindow().

int BR_Win32_GetWindowLong(void* hwnd, int index)
int BR_Win32_GetWindowLong(void* hwnd, int index) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_GetWindowLong", void* hwnd, int index) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_GetWindowLong(identifier hwnd, integer index)
Int BR_Win32_GetWindowLong(void hwnd, Int index)

[BR] Equivalent to win32 API GetWindowLong().

bool BR_Win32_GetWindowRect(void* hwnd, int* leftOut, int* topOut, int* rightOut, int* bottomOut)
bool BR_Win32_GetWindowRect(void* hwnd, int &left, int &top, int &right, int &bottom) (requires REAPER 6.24 or later)
bool extension_api("BR_Win32_GetWindowRect", void* hwnd, int &left, int &top, int &right, int &bottom) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer left, integer top, integer right, integer bottom = reaper.BR_Win32_GetWindowRect(identifier hwnd)
(Boolean retval, void hwnd, Int leftOut, Int topOut, Int rightOut, Int bottomOut) = BR_Win32_GetWindowRect(hwnd, leftOut, topOut, rightOut, bottomOut)

[BR] Equivalent to win32 API GetWindowRect().

int BR_Win32_GetWindowText(void* hwnd, char* textOut, int textOut_sz)
int BR_Win32_GetWindowText(void* hwnd, #text) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_GetWindowText", void* hwnd, #text) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string text = reaper.BR_Win32_GetWindowText(identifier hwnd)
(Int retval, void hwnd, String textOut, Int textOut_sz) = BR_Win32_GetWindowText(hwnd, textOut, textOut_sz)

[BR] Equivalent to win32 API GetWindowText().

int BR_Win32_HIBYTE(int value)
int BR_Win32_HIBYTE(int value) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_HIBYTE", int value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_HIBYTE(integer value)
Int BR_Win32_HIBYTE(Int value)

[BR] Equivalent to win32 API HIBYTE().

int BR_Win32_HIWORD(int value)
int BR_Win32_HIWORD(int value) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_HIWORD", int value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_HIWORD(integer value)
Int BR_Win32_HIWORD(Int value)

[BR] Equivalent to win32 API HIWORD().

void BR_Win32_HwndToString(void* hwnd, char* stringOut, int stringOut_sz)
BR_Win32_HwndToString(void* hwnd, #string) (requires REAPER 6.24 or later)
extension_api("BR_Win32_HwndToString", void* hwnd, #string) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string string = reaper.BR_Win32_HwndToString(identifier hwnd)
(void hwnd, String stringOut, Int stringOut_sz) = BR_Win32_HwndToString(hwnd, stringOut, stringOut_sz)

[BR] Convert HWND to string. To convert string back to HWND, see BR_Win32_StringToHwnd.

bool BR_Win32_IsWindow(void* hwnd)
bool BR_Win32_IsWindow(void* hwnd) (requires REAPER 6.24 or later)
bool extension_api("BR_Win32_IsWindow", void* hwnd) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_Win32_IsWindow(identifier hwnd)
Boolean BR_Win32_IsWindow(void hwnd)

[BR] Equivalent to win32 API IsWindow().

bool BR_Win32_IsWindowVisible(void* hwnd)
bool BR_Win32_IsWindowVisible(void* hwnd) (requires REAPER 6.24 or later)
bool extension_api("BR_Win32_IsWindowVisible", void* hwnd) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_Win32_IsWindowVisible(identifier hwnd)
Boolean BR_Win32_IsWindowVisible(void hwnd)

[BR] Equivalent to win32 API IsWindowVisible().

int BR_Win32_LOBYTE(int value)
int BR_Win32_LOBYTE(int value) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_LOBYTE", int value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_LOBYTE(integer value)
Int BR_Win32_LOBYTE(Int value)

[BR] Equivalent to win32 API LOBYTE().

int BR_Win32_LOWORD(int value)
int BR_Win32_LOWORD(int value) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_LOWORD", int value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_LOWORD(integer value)
Int BR_Win32_LOWORD(Int value)

[BR] Equivalent to win32 API LOWORD().

int BR_Win32_MAKELONG(int low, int high)
int BR_Win32_MAKELONG(int low, int high) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_MAKELONG", int low, int high) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_MAKELONG(integer low, integer high)
Int BR_Win32_MAKELONG(Int low, Int high)

[BR] Equivalent to win32 API MAKELONG().

int BR_Win32_MAKELPARAM(int low, int high)
int BR_Win32_MAKELPARAM(int low, int high) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_MAKELPARAM", int low, int high) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_MAKELPARAM(integer low, integer high)
Int BR_Win32_MAKELPARAM(Int low, Int high)

[BR] Equivalent to win32 API MAKELPARAM().

int BR_Win32_MAKELRESULT(int low, int high)
int BR_Win32_MAKELRESULT(int low, int high) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_MAKELRESULT", int low, int high) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_MAKELRESULT(integer low, integer high)
Int BR_Win32_MAKELRESULT(Int low, Int high)

[BR] Equivalent to win32 API MAKELRESULT().

int BR_Win32_MAKEWORD(int low, int high)
int BR_Win32_MAKEWORD(int low, int high) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_MAKEWORD", int low, int high) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_MAKEWORD(integer low, integer high)
Int BR_Win32_MAKEWORD(Int low, Int high)

[BR] Equivalent to win32 API MAKEWORD().

int BR_Win32_MAKEWPARAM(int low, int high)
int BR_Win32_MAKEWPARAM(int low, int high) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_MAKEWPARAM", int low, int high) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_MAKEWPARAM(integer low, integer high)
Int BR_Win32_MAKEWPARAM(Int low, Int high)

[BR] Equivalent to win32 API MAKEWPARAM().

void* BR_Win32_MIDIEditor_GetActive()
void* BR_Win32_MIDIEditor_GetActive() (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_MIDIEditor_GetActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_MIDIEditor_GetActive()
void BR_Win32_MIDIEditor_GetActive()

[BR] Alternative to MIDIEditor_GetActive. REAPER seems to have problems with extensions using HWND type for exported functions so all BR_Win32 functions use void* instead of HWND type.

void BR_Win32_ScreenToClient(void* hwnd, int xIn, int yIn, int* xOut, int* yOut)
BR_Win32_ScreenToClient(void* hwnd, int xIn, int yIn, int &x, int &y) (requires REAPER 6.24 or later)
extension_api("BR_Win32_ScreenToClient", void* hwnd, int xIn, int yIn, int &x, int &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer x, integer y = reaper.BR_Win32_ScreenToClient(identifier hwnd, integer xIn, integer yIn)
(void hwnd, Int xIn, Int yIn, Int xOut, Int yOut) = BR_Win32_ScreenToClient(hwnd, xIn, yIn, xOut, yOut)

[BR] Equivalent to win32 API ClientToScreen().

int BR_Win32_SendMessage(void* hwnd, int msg, int lParam, int wParam)
int BR_Win32_SendMessage(void* hwnd, int msg, int lParam, int wParam) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_SendMessage", void* hwnd, int msg, int lParam, int wParam) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_SendMessage(identifier hwnd, integer msg, integer lParam, integer wParam)
Int BR_Win32_SendMessage(void hwnd, Int msg, Int lParam, Int wParam)

[BR] Equivalent to win32 API SendMessage().

void* BR_Win32_SetFocus(void* hwnd)
void* BR_Win32_SetFocus(void* hwnd) (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_SetFocus", void* hwnd) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_SetFocus(identifier hwnd)
void BR_Win32_SetFocus(void hwnd)

[BR] Equivalent to win32 API SetFocus().

int BR_Win32_SetForegroundWindow(void* hwnd)
int BR_Win32_SetForegroundWindow(void* hwnd) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_SetForegroundWindow", void* hwnd) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_SetForegroundWindow(identifier hwnd)
Int BR_Win32_SetForegroundWindow(void hwnd)

[BR] Equivalent to win32 API SetForegroundWindow().

int BR_Win32_SetWindowLong(void* hwnd, int index, int newLong)
int BR_Win32_SetWindowLong(void* hwnd, int index, int newLong) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_SetWindowLong", void* hwnd, int index, int newLong) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_SetWindowLong(identifier hwnd, integer index, integer newLong)
Int BR_Win32_SetWindowLong(void hwnd, Int index, Int newLong)

[BR] Equivalent to win32 API SetWindowLong().

bool BR_Win32_SetWindowPos(void* hwnd, const char* hwndInsertAfter, int x, int y, int width, int height, int flags)
bool BR_Win32_SetWindowPos(void* hwnd, "hwndInsertAfter", int x, int y, int width, int height, int flags) (requires REAPER 6.24 or later)
bool extension_api("BR_Win32_SetWindowPos", void* hwnd, "hwndInsertAfter", int x, int y, int width, int height, int flags) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_Win32_SetWindowPos(identifier hwnd, string hwndInsertAfter, integer x, integer y, integer width, integer height, integer flags)
Boolean BR_Win32_SetWindowPos(void hwnd, String hwndInsertAfter, Int x, Int y, Int width, Int height, Int flags)

[BR] Equivalent to win32 API SetWindowPos().
hwndInsertAfter may be a string: "HWND_BOTTOM", "HWND_NOTOPMOST", "HWND_TOP", "HWND_TOPMOST" or a string obtained with BR_Win32_HwndToString.

int BR_Win32_ShellExecute(const char* operation, const char* file, const char* parameters, const char* directory, int showFlags)
int BR_Win32_ShellExecute("operation", "file", "parameters", "directory", int showFlags) (requires REAPER 6.24 or later)
int extension_api("BR_Win32_ShellExecute", "operation", "file", "parameters", "directory", int showFlags) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.BR_Win32_ShellExecute(string operation, string file, string parameters, string directory, integer showFlags)
Int BR_Win32_ShellExecute(String operation, String file, String parameters, String directory, Int showFlags)

[BR] Equivalent to win32 API ShellExecute() with HWND set to main window

bool BR_Win32_ShowWindow(void* hwnd, int cmdShow)
bool BR_Win32_ShowWindow(void* hwnd, int cmdShow) (requires REAPER 6.24 or later)
bool extension_api("BR_Win32_ShowWindow", void* hwnd, int cmdShow) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_Win32_ShowWindow(identifier hwnd, integer cmdShow)
Boolean BR_Win32_ShowWindow(void hwnd, Int cmdShow)

[BR] Equivalent to win32 API ShowWindow().

void* BR_Win32_StringToHwnd(const char* string)
void* BR_Win32_StringToHwnd("string") (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_StringToHwnd", "string") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_StringToHwnd(string string)
void BR_Win32_StringToHwnd(String string)

[BR] Convert string to HWND. To convert HWND back to string, see BR_Win32_HwndToString.

void* BR_Win32_WindowFromPoint(int x, int y)
void* BR_Win32_WindowFromPoint(int x, int y) (requires REAPER 6.24 or later)
void* extension_api("BR_Win32_WindowFromPoint", int x, int y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.BR_Win32_WindowFromPoint(integer x, integer y)
void BR_Win32_WindowFromPoint(Int x, Int y)

[BR] Equivalent to win32 API WindowFromPoint().

bool BR_Win32_WritePrivateProfileString(const char* sectionName, const char* keyName, const char* value, const char* filePath)
bool BR_Win32_WritePrivateProfileString("sectionName", "keyName", "value", "filePath") (requires REAPER 6.24 or later)
bool extension_api("BR_Win32_WritePrivateProfileString", "sectionName", "keyName", "value", "filePath") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.BR_Win32_WritePrivateProfileString(string sectionName, string keyName, string value, string filePath)
Boolean BR_Win32_WritePrivateProfileString(String sectionName, String keyName, String value, String filePath)

[BR] Equivalent to win32 API WritePrivateProfileString(). For example, you can use this to write to REAPER.ini. You can pass an empty string as value to delete a key.

CF_Preview* CF_CreatePreview(PCM_source* source)
CF_Preview CF_CreatePreview(PCM_source source) (requires REAPER 6.24 or later)
CF_Preview extension_api("CF_CreatePreview", PCM_source source) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
CF_Preview reaper.CF_CreatePreview(PCM_source source)
CF_Preview CF_CreatePreview(PCM_source source)

Create a new preview object. Does not take ownership of the source (don't forget to destroy it unless it came from a take!). See CF_Preview_Play and the others CF_Preview_* functions.

The preview object is automatically destroyed at the end of a defer cycle if at least one of these conditions are met:
- playback finished
- playback was not started using CF_Preview_Play
- the output track no longer exists

int CF_EnumMediaSourceCues(PCM_source* src, int index, double* timeOut, double* endTimeOut, bool* isRegionOut, char* nameOut, int nameOut_sz, bool* isChapterOut)
int CF_EnumMediaSourceCues(PCM_source src, int index, &time, &endTime, bool &isRegion, #name, bool &isChapter) (requires REAPER 6.24 or later)
int extension_api("CF_EnumMediaSourceCues", PCM_source src, int index, &time, &endTime, bool &isRegion, #name, bool &isChapter) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, number time, number endTime, boolean isRegion, string name, boolean isChapter = reaper.CF_EnumMediaSourceCues(PCM_source src, integer index)
(Int retval, PCM_source src, Int index, Float timeOut, Float endTimeOut, Boolean isRegionOut, String nameOut, Int nameOut_sz, Boolean isChapterOut) = CF_EnumMediaSourceCues(src, index, timeOut, endTimeOut, isRegionOut, nameOut, nameOut_sz, isChapterOut)

Enumerate the source's media cues. Returns the next index or 0 when finished.

int CF_EnumSelectedFX(FxChain* hwnd, int index)
int CF_EnumSelectedFX(FxChain hwnd, int index) (requires REAPER 6.24 or later)
int extension_api("CF_EnumSelectedFX", FxChain hwnd, int index) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.CF_EnumSelectedFX(FxChain hwnd, integer index)
Int CF_EnumSelectedFX(FxChain hwnd, Int index)

Return the index of the next selected effect in the given FX chain. Start index should be -1. Returns -1 if there are no more selected effects.

int CF_EnumerateActions(int section, int index, char* nameOut, int nameOut_sz)
int CF_EnumerateActions(int section, int index, #name) (requires REAPER 6.24 or later)
int extension_api("CF_EnumerateActions", int section, int index, #name) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string name = reaper.CF_EnumerateActions(integer section, integer index)
(Int retval, Int section, Int index, String nameOut, Int nameOut_sz) = CF_EnumerateActions(section, index, nameOut, nameOut_sz)

Deprecated, see kbd_enumerateActions (v6.71+). Wrapper for the unexposed kbd_enumerateActions API function.
Main=0, Main (alt recording)=100, MIDI Editor=32060, MIDI Event List Editor=32061, MIDI Inline Editor=32062, Media Explorer=32063

bool CF_ExportMediaSource(PCM_source* src, const char* fn)
bool CF_ExportMediaSource(PCM_source src, "fn") (requires REAPER 6.24 or later)
bool extension_api("CF_ExportMediaSource", PCM_source src, "fn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_ExportMediaSource(PCM_source src, string fn)
Boolean CF_ExportMediaSource(PCM_source src, String fn)

Export the source to the given file (MIDI only).

void CF_GetClipboard(char* textOutNeedBig, int textOutNeedBig_sz)
CF_GetClipboard(#text) (requires REAPER 6.24 or later)
extension_api("CF_GetClipboard", #text) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string text = reaper.CF_GetClipboard()
(String textOutNeedBig, Int textOutNeedBig_sz) = CF_GetClipboard(textOutNeedBig, textOutNeedBig_sz)

Read the contents of the system clipboard.

const char* CF_GetClipboardBig(WDL_FastString* output)
bool CF_GetClipboardBig(#retval, WDL_FastString output) (requires REAPER 6.24 or later)
bool extension_api("CF_GetClipboardBig", #retval, WDL_FastString output) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string reaper.CF_GetClipboardBig(WDL_FastString output)
String CF_GetClipboardBig(WDL_FastString output)

[DEPRECATED: Use CF_GetClipboard] Read the contents of the system clipboard. See SNM_CreateFastString and SNM_DeleteFastString.

const char* CF_GetCommandText(int section, int command)
bool CF_GetCommandText(#retval, int section, int command) (requires REAPER 6.24 or later)
bool extension_api("CF_GetCommandText", #retval, int section, int command) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string reaper.CF_GetCommandText(integer section, integer command)
String CF_GetCommandText(Int section, Int command)

Deprecated, see kbd_getTextFromCmd (v6.71+). Wrapper for the unexposed kbd_getTextFromCmd API function. See CF_EnumerateActions for common section IDs.

int CF_GetCustomColor(int index)
int CF_GetCustomColor(int index) (requires REAPER 6.24 or later)
int extension_api("CF_GetCustomColor", int index) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.CF_GetCustomColor(integer index)
Int CF_GetCustomColor(Int index)

Get one of 16 SWS custom colors (0xBBGGRR on Windows, 0xRRGGBB everyhwere else). Index is zero-based.

FxChain* CF_GetFocusedFXChain()
FxChain CF_GetFocusedFXChain() (requires REAPER 6.24 or later)
FxChain extension_api("CF_GetFocusedFXChain") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
FxChain = reaper.CF_GetFocusedFXChain()
FxChain CF_GetFocusedFXChain()

Return a handle to the currently focused FX chain window.

int CF_GetMediaSourceBitDepth(PCM_source* src)
int CF_GetMediaSourceBitDepth(PCM_source src) (requires REAPER 6.24 or later)
int extension_api("CF_GetMediaSourceBitDepth", PCM_source src) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.CF_GetMediaSourceBitDepth(PCM_source src)
Int CF_GetMediaSourceBitDepth(PCM_source src)

Returns the bit depth if available (0 otherwise).

double CF_GetMediaSourceBitRate(PCM_source* src)
double CF_GetMediaSourceBitRate(PCM_source src) (requires REAPER 6.24 or later)
double extension_api("CF_GetMediaSourceBitRate", PCM_source src) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.CF_GetMediaSourceBitRate(PCM_source src)
Float CF_GetMediaSourceBitRate(PCM_source src)

Returns the bit rate for WAVE (wav, aif) and streaming/variable formats (mp3, ogg, opus). REAPER v6.19 or later is required for non-WAVE formats.

bool CF_GetMediaSourceMetadata(PCM_source* src, const char* name, char* out, int out_sz)
bool CF_GetMediaSourceMetadata(PCM_source src, "name", #out) (requires REAPER 6.24 or later)
bool extension_api("CF_GetMediaSourceMetadata", PCM_source src, "name", #out) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string out = reaper.CF_GetMediaSourceMetadata(PCM_source src, string name, string out)
(Boolean retval, PCM_source src, String name, String out, Int out_sz) = CF_GetMediaSourceMetadata(src, name, out, out_sz)

Get the value of the given metadata field (eg. DESC, ORIG, ORIGREF, DATE, TIME, UMI, CODINGHISTORY for BWF).

bool CF_GetMediaSourceOnline(PCM_source* src)
bool CF_GetMediaSourceOnline(PCM_source src) (requires REAPER 6.24 or later)
bool extension_api("CF_GetMediaSourceOnline", PCM_source src) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_GetMediaSourceOnline(PCM_source src)
Boolean CF_GetMediaSourceOnline(PCM_source src)

Returns the online/offline status of the given source.

bool CF_GetMediaSourceRPP(PCM_source* src, char* fnOut, int fnOut_sz)
bool CF_GetMediaSourceRPP(PCM_source src, #fn) (requires REAPER 6.24 or later)
bool extension_api("CF_GetMediaSourceRPP", PCM_source src, #fn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string fn = reaper.CF_GetMediaSourceRPP(PCM_source src)
(Boolean retval, PCM_source src, String fnOut, Int fnOut_sz) = CF_GetMediaSourceRPP(src, fnOut, fnOut_sz)

Get the project associated with this source (BWF, subproject...).

void CF_GetSWSVersion(char* versionOut, int versionOut_sz)
CF_GetSWSVersion(#version) (requires REAPER 6.24 or later)
extension_api("CF_GetSWSVersion", #version) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string version = reaper.CF_GetSWSVersion()
(String versionOut, Int versionOut_sz) = CF_GetSWSVersion(versionOut, versionOut_sz)

Return the current SWS version number.

FxChain* CF_GetTakeFXChain(MediaItem_Take* take)
FxChain CF_GetTakeFXChain(MediaItem_Take take) (requires REAPER 6.24 or later)
FxChain extension_api("CF_GetTakeFXChain", MediaItem_Take take) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
FxChain reaper.CF_GetTakeFXChain(MediaItem_Take take)
FxChain CF_GetTakeFXChain(MediaItem_Take take)

Return a handle to the given take FX chain window. HACK: This temporarily renames the take in order to disambiguate the take FX chain window from similarily named takes.

FxChain* CF_GetTrackFXChain(MediaTrack* track)
FxChain CF_GetTrackFXChain(MediaTrack track) (requires REAPER 6.24 or later)
FxChain extension_api("CF_GetTrackFXChain", MediaTrack track) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
FxChain reaper.CF_GetTrackFXChain(MediaTrack track)
FxChain CF_GetTrackFXChain(MediaTrack track)

Return a handle to the given track FX chain window.

FxChain* CF_GetTrackFXChainEx(ReaProject* project, MediaTrack* track, bool wantInputChain)
FxChain CF_GetTrackFXChainEx(ReaProject project, MediaTrack track, bool wantInputChain) (requires REAPER 6.24 or later)
FxChain extension_api("CF_GetTrackFXChainEx", ReaProject project, MediaTrack track, bool wantInputChain) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
FxChain reaper.CF_GetTrackFXChainEx(ReaProject project, MediaTrack track, boolean wantInputChain)
FxChain CF_GetTrackFXChainEx(ReaProject project, MediaTrack track, Boolean wantInputChain)

Return a handle to the given track FX chain window. Set wantInputChain to get the track's input/monitoring FX chain.

bool CF_LocateInExplorer(const char* file)
bool CF_LocateInExplorer("file") (requires REAPER 6.24 or later)
bool extension_api("CF_LocateInExplorer", "file") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_LocateInExplorer(string file)
Boolean CF_LocateInExplorer(String file)

Select the given file in explorer/finder.

bool CF_PCM_Source_SetSectionInfo(PCM_source* section, PCM_source* source, double offset, double length, bool reverse)
bool CF_PCM_Source_SetSectionInfo(PCM_source section, PCM_source source, offset, length, bool reverse) (requires REAPER 6.24 or later)
bool extension_api("CF_PCM_Source_SetSectionInfo", PCM_source section, PCM_source source, offset, length, bool reverse) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_PCM_Source_SetSectionInfo(PCM_source section, PCM_source source, number offset, number length, boolean reverse)
Boolean CF_PCM_Source_SetSectionInfo(PCM_source section, PCM_source source, Float offset, Float length, Boolean reverse)

Give a section source created using PCM_Source_CreateFromType("SECTION"). Offset and length are ignored if 0. Negative length to subtract from the total length of the source.

bool CF_Preview_GetPeak(CF_Preview* preview, int channel, double* peakvolOut)
bool CF_Preview_GetPeak(CF_Preview preview, int channel, &peakvol) (requires REAPER 6.24 or later)
bool extension_api("CF_Preview_GetPeak", CF_Preview preview, int channel, &peakvol) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number peakvol = reaper.CF_Preview_GetPeak(CF_Preview preview, integer channel)
(Boolean retval, CF_Preview preview, Int channel, Float peakvolOut) = CF_Preview_GetPeak(preview, channel, peakvolOut)

Read peak volume for channel 0 or 1. Only available when outputting to a hardware output (not through a track).

bool CF_Preview_GetValue(CF_Preview* preview, const char* name, double* valueOut)
bool CF_Preview_GetValue(CF_Preview preview, "name", &value) (requires REAPER 6.24 or later)
bool extension_api("CF_Preview_GetValue", CF_Preview preview, "name", &value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number value = reaper.CF_Preview_GetValue(CF_Preview preview, string name)
(Boolean retval, CF_Preview preview, String name, Float valueOut) = CF_Preview_GetValue(preview, name, valueOut)

Supported attributes:
B_LOOP seek to the beginning when reaching the end of the source
B_PPITCH preserve pitch when changing playback rate
D_FADEINLEN lenght in seconds of playback fade in
D_FADEOUTLEN lenght in seconds of playback fade out
D_LENGTH (read only) length of the source * playback rate
D_MEASUREALIGN >0 = wait until the next bar before starting playback (note: this causes playback to silently continue when project is paused and previewing through a track)
D_PAN playback pan
D_PITCH pitch adjustment in semitones
D_PLAYRATE playback rate
D_POSITION current playback position
D_VOLUME playback volume
I_OUTCHAN first hardware output channel (&1024=mono, reads -1 when playing through a track, see CF_Preview_SetOutputTrack)
I_PITCHMODE highest 16 bits=pitch shift mode (see EnumPitchShiftModes), lower 16 bits=pitch shift submode (see EnumPitchShiftSubModes)

bool CF_Preview_Play(CF_Preview* preview)
bool CF_Preview_Play(CF_Preview preview) (requires REAPER 6.24 or later)
bool extension_api("CF_Preview_Play", CF_Preview preview) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_Preview_Play(CF_Preview preview)
Boolean CF_Preview_Play(CF_Preview preview)

Start playback of the configured preview object.

bool CF_Preview_SetOutputTrack(CF_Preview* preview, ReaProject* project, MediaTrack* track)
bool CF_Preview_SetOutputTrack(CF_Preview preview, ReaProject project, MediaTrack track) (requires REAPER 6.24 or later)
bool extension_api("CF_Preview_SetOutputTrack", CF_Preview preview, ReaProject project, MediaTrack track) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_Preview_SetOutputTrack(CF_Preview preview, ReaProject project, MediaTrack track)
Boolean CF_Preview_SetOutputTrack(CF_Preview preview, ReaProject project, MediaTrack track)
bool CF_Preview_SetValue(CF_Preview* preview, const char* name, double newValue)
bool CF_Preview_SetValue(CF_Preview preview, "name", newValue) (requires REAPER 6.24 or later)
bool extension_api("CF_Preview_SetValue", CF_Preview preview, "name", newValue) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_Preview_SetValue(CF_Preview preview, string name, number newValue)
Boolean CF_Preview_SetValue(CF_Preview preview, String name, Float newValue)

See CF_Preview_GetValue.

bool CF_Preview_Stop(CF_Preview* preview)
bool CF_Preview_Stop(CF_Preview preview) (requires REAPER 6.24 or later)
bool extension_api("CF_Preview_Stop", CF_Preview preview) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_Preview_Stop(CF_Preview preview)
Boolean CF_Preview_Stop(CF_Preview preview)

Stop and destroy a preview object.

void CF_Preview_StopAll()
CF_Preview_StopAll() (requires REAPER 6.24 or later)
extension_api("CF_Preview_StopAll") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.CF_Preview_StopAll()
CF_Preview_StopAll()

Stop and destroy all currently active preview objects.

bool CF_SelectTrackFX(MediaTrack* track, int index)
bool CF_SelectTrackFX(MediaTrack track, int index) (requires REAPER 6.24 or later)
bool extension_api("CF_SelectTrackFX", MediaTrack track, int index) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_SelectTrackFX(MediaTrack track, integer index)
Boolean CF_SelectTrackFX(MediaTrack track, Int index)

Set which track effect is active in the track's FX chain. The FX chain window does not have to be open.

void CF_SetClipboard(const char* str)
CF_SetClipboard("str") (requires REAPER 6.24 or later)
extension_api("CF_SetClipboard", "str") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.CF_SetClipboard(string str)
CF_SetClipboard(String str)

Write the given string into the system clipboard.

void CF_SetCustomColor(int index, int color)
CF_SetCustomColor(int index, int color) (requires REAPER 6.24 or later)
extension_api("CF_SetCustomColor", int index, int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.CF_SetCustomColor(integer index, integer color)
CF_SetCustomColor(Int index, Int color)

Set one of 16 SWS custom colors (0xBBGGRR on Windows, 0xRRGGBB everyhwere else). Index is zero-based.

void CF_SetMediaSourceOnline(PCM_source* src, bool set)
CF_SetMediaSourceOnline(PCM_source src, bool set) (requires REAPER 6.24 or later)
extension_api("CF_SetMediaSourceOnline", PCM_source src, bool set) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.CF_SetMediaSourceOnline(PCM_source src, boolean set)
CF_SetMediaSourceOnline(PCM_source src, Boolean set)

Set the online/offline status of the given source (closes files when set=false).

bool CF_ShellExecute(const char* file)
bool CF_ShellExecute("file") (requires REAPER 6.24 or later)
bool extension_api("CF_ShellExecute", "file") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.CF_ShellExecute(string file)
Boolean CF_ShellExecute(String file)

Open the given file or URL in the default application. See also CF_LocateInExplorer.

RprMidiNote* FNG_AddMidiNote(RprMidiTake* midiTake)
RprMidiNote FNG_AddMidiNote(RprMidiTake midiTake) (requires REAPER 6.24 or later)
RprMidiNote extension_api("FNG_AddMidiNote", RprMidiTake midiTake) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
RprMidiNote reaper.FNG_AddMidiNote(RprMidiTake midiTake)
RprMidiNote FNG_AddMidiNote(RprMidiTake midiTake)

[FNG] Add MIDI note to MIDI take

RprMidiTake* FNG_AllocMidiTake(MediaItem_Take* take)
RprMidiTake FNG_AllocMidiTake(MediaItem_Take take) (requires REAPER 6.24 or later)
RprMidiTake extension_api("FNG_AllocMidiTake", MediaItem_Take take) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
RprMidiTake reaper.FNG_AllocMidiTake(MediaItem_Take take)
RprMidiTake FNG_AllocMidiTake(MediaItem_Take take)

[FNG] Allocate a RprMidiTake from a take pointer. Returns a NULL pointer if the take is not an in-project MIDI take

int FNG_CountMidiNotes(RprMidiTake* midiTake)
int FNG_CountMidiNotes(RprMidiTake midiTake) (requires REAPER 6.24 or later)
int extension_api("FNG_CountMidiNotes", RprMidiTake midiTake) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.FNG_CountMidiNotes(RprMidiTake midiTake)
Int FNG_CountMidiNotes(RprMidiTake midiTake)

[FNG] Count of how many MIDI notes are in the MIDI take

void FNG_FreeMidiTake(RprMidiTake* midiTake)
FNG_FreeMidiTake(RprMidiTake midiTake) (requires REAPER 6.24 or later)
extension_api("FNG_FreeMidiTake", RprMidiTake midiTake) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.FNG_FreeMidiTake(RprMidiTake midiTake)
FNG_FreeMidiTake(RprMidiTake midiTake)

[FNG] Commit changes to MIDI take and free allocated memory

RprMidiNote* FNG_GetMidiNote(RprMidiTake* midiTake, int index)
RprMidiNote FNG_GetMidiNote(RprMidiTake midiTake, int index) (requires REAPER 6.24 or later)
RprMidiNote extension_api("FNG_GetMidiNote", RprMidiTake midiTake, int index) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
RprMidiNote reaper.FNG_GetMidiNote(RprMidiTake midiTake, integer index)
RprMidiNote FNG_GetMidiNote(RprMidiTake midiTake, Int index)

[FNG] Get a MIDI note from a MIDI take at specified index

int FNG_GetMidiNoteIntProperty(RprMidiNote* midiNote, const char* property)
int FNG_GetMidiNoteIntProperty(RprMidiNote midiNote, "property") (requires REAPER 6.24 or later)
int extension_api("FNG_GetMidiNoteIntProperty", RprMidiNote midiNote, "property") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.FNG_GetMidiNoteIntProperty(RprMidiNote midiNote, string property)
Int FNG_GetMidiNoteIntProperty(RprMidiNote midiNote, String property)

[FNG] Get MIDI note property

void FNG_SetMidiNoteIntProperty(RprMidiNote* midiNote, const char* property, int value)
FNG_SetMidiNoteIntProperty(RprMidiNote midiNote, "property", int value) (requires REAPER 6.24 or later)
extension_api("FNG_SetMidiNoteIntProperty", RprMidiNote midiNote, "property", int value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.FNG_SetMidiNoteIntProperty(RprMidiNote midiNote, string property, integer value)
FNG_SetMidiNoteIntProperty(RprMidiNote midiNote, String property, Int value)

[FNG] Set MIDI note property

bool Fab_Clear(const char* idStringInOptional)
bool Fab_Clear(optional "idStringIn") (requires REAPER 6.24 or later)
bool extension_api("Fab_Clear", optional "idStringIn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.Fab_Clear(optional string idStringIn)
Boolean Fab_Clear(String idStringInOptional)

Clears ReaFab control map, optionally based on matching idString. Returns true on success.

bool Fab_Do(int command, int val)
bool Fab_Do(int command, int val) (requires REAPER 6.24 or later)
bool extension_api("Fab_Do", int command, int val) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.Fab_Do(integer command, integer val)
Boolean Fab_Do(Int command, Int val)

Runs ReaFab actions/commands. First parameter (command) is ReaFab command number, e.g. 3 for 3rd encoder rotation. Second parameter (val) is MIDI CC Relative value. Value 1 is increment of 1, 127 is decrement of 1. 2 is inc 2, 126 is dec 2 and so on. For button press (commands 9-32) a value of 127 is recommended.

void Fab_Dump()
Fab_Dump() (requires REAPER 6.24 or later)
extension_api("Fab_Dump") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.Fab_Dump()
Fab_Dump()

Dumps current control mapping into .lua file under ResourcePath/Scripts/reafab_dump-timestamp.lua

bool Fab_Get(int command, int* fxOut, int* paramOut)
bool Fab_Get(int command, int &fx, int &param) (requires REAPER 6.24 or later)
bool extension_api("Fab_Get", int command, int &fx, int &param) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer fx, integer param = reaper.Fab_Get(integer command)
(Boolean retval, Int command, Int fxOut, Int paramOut) = Fab_Get(command, fxOut, paramOut)

Returns target FX and parameter index for given ReaFab command in context of selected track and ReaFab FX index. Valid command range 1 ... 24. Returns false if no such command mapping is found. Returns param index -1 for ReaFab internal band change command.

bool Fab_Map(const char* fxId, int command, const char* paramId, int control, int* bandsInOptional, double* stepInOptional, double* accelInOptional, double* minvalInOptional, double* maxvalInOptional)
bool Fab_Map("fxId", int command, "paramId", int control, optional int bandsIn, optional stepIn, optional accelIn, optional minvalIn, optional maxvalIn) (requires REAPER 6.24 or later)
bool extension_api("Fab_Map", "fxId", int command, "paramId", int control, optional int bandsIn, optional stepIn, optional accelIn, optional minvalIn, optional maxvalIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.Fab_Map(string fxId, integer command, string paramId, integer control, optional integer bandsIn, optional number stepIn, optional number accelIn, optional number minvalIn, optional number maxvalIn)
(Boolean retval, String fxId, Int command, String paramId, Int control, Int bandsInOptional, Float stepInOptional, Float accelInOptional, Float minvalInOptional, Float maxvalInOptional) = Fab_Map(fxId, command, paramId, control, bandsInOptional, stepInOptional, accelInOptional, minvalInOptional, maxvalInOptional)

Creates control mapping for ReaFab command.
fxId e.g. "ReaComp".
command 1-8 for encoders, 9-24 for buttons.
paramId e.g. "Ratio".
control 1 = direct, 2 = band selector, 3 = cycle, 4 = invert, 5 = force toggle, 6 = force range, 7 = 5 and 6, 8 = force continuous.
bands define, if target fx has multiple identical target bands. In this case, paramId must include 00 placeholder, e.g. "Band 00 Gain".
step overrides built-in default step of ~0.001 for continuous parameters.
accel overrides built-in default control acceleration step of 1.0.
minval & maxval override default detected target param value range.
Prefixing paramId with "-" reverses direction; useful for creating separate next/previous mappings for bands or list type value navigation.

bool GU_Config_Read(const char* fileName, const char* category, const char* key, char* valueOut, int valueOut_sz)
bool GU_Config_Read("fileName", "category", "key", #value) (requires REAPER 6.24 or later)
bool extension_api("GU_Config_Read", "fileName", "category", "key", #value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string value = reaper.GU_Config_Read(string fileName, string category, string key)
(Boolean retval, String fileName, String category, String key, String valueOut, Int valueOut_sz) = GU_Config_Read(fileName, category, key, valueOut, valueOut_sz)

Reads from a config file in the GUtilities folder in Reaper's resource folder

bool GU_Config_Write(const char* fileName, const char* category, const char* key, const char* value)
bool GU_Config_Write("fileName", "category", "key", "value") (requires REAPER 6.24 or later)
bool extension_api("GU_Config_Write", "fileName", "category", "key", "value") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.GU_Config_Write(string fileName, string category, string key, string value)
Boolean GU_Config_Write(String fileName, String category, String key, String value)

Writes a config file to the GUtilities folder in Reaper's resource folder

int GU_Filesystem_CountMediaFiles(const char* path, int flags, double* fileSizeOut)
int GU_Filesystem_CountMediaFiles("path", int flags, &fileSize) (requires REAPER 6.24 or later)
int extension_api("GU_Filesystem_CountMediaFiles", "path", int flags, &fileSize) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, number fileSize = reaper.GU_Filesystem_CountMediaFiles(string path, integer flags)
(Int retval, String path, Int flags, Float fileSizeOut) = GU_Filesystem_CountMediaFiles(path, flags, fileSizeOut)

Returns count and filesize in megabytes for all valid media files within the path. Returns -1 if path is invalid. Flags can be passed as an argument to determine which media files are valid. A flag with a value of -1 will reset the cache, otherwise, the following flags can be used: ALL = 0, WAV = 1, AIFF = 2, FLAC = 4, MP3 = 8, OGG = 16, BWF = 32, W64 = 64, WAVPACK = 128, GIF = 256, MP4 = 512

void GU_Filesystem_EnumerateMediaFiles(const char* path, int flags, char* pathOut, int pathOut_sz)
GU_Filesystem_EnumerateMediaFiles("path", int flags, #path) (requires REAPER 6.24 or later)
extension_api("GU_Filesystem_EnumerateMediaFiles", "path", int flags, #path) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string path = reaper.GU_Filesystem_EnumerateMediaFiles(string path, integer flags)
(String path, Int flags, String pathOut, Int pathOut_sz) = GU_Filesystem_EnumerateMediaFiles(path, flags, pathOut, pathOut_sz)

Returns the next valid file in a directory each time this function is called with the same path. Returns an empty string if path does not contain any more valid files. Flags can be passed as an argument to determine which media files are valid. A flag with a value of -1 will reset the cache, otherwise, the following flags can be used: ALL = 0, WAV = 1, AIFF = 2, FLAC = 4, MP3 = 8, OGG = 16, BWF = 32, W64 = 64, WAVPACK = 128, GIF = 256, MP4 = 512

void GU_Filesystem_FindFileInPath(const char* path, const char* fileName, char* pathOut, int pathOut_sz)
GU_Filesystem_FindFileInPath("path", "fileName", #path) (requires REAPER 6.24 or later)
extension_api("GU_Filesystem_FindFileInPath", "path", "fileName", #path) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string path = reaper.GU_Filesystem_FindFileInPath(string path, string fileName)
(String path, String fileName, String pathOut, Int pathOut_sz) = GU_Filesystem_FindFileInPath(path, fileName, pathOut, pathOut_sz)

Returns the first found file's path from within a given path. Returns an empty string if not found

bool GU_Filesystem_PathExists(const char* path)
bool GU_Filesystem_PathExists("path") (requires REAPER 6.24 or later)
bool extension_api("GU_Filesystem_PathExists", "path") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.GU_Filesystem_PathExists(string path)
Boolean GU_Filesystem_PathExists(String path)

Checks if file or directory exists

void GU_GUtilitiesAPI_GetVersion(char* versionOut, int versionOut_sz)
GU_GUtilitiesAPI_GetVersion(#version) (requires REAPER 6.24 or later)
extension_api("GU_GUtilitiesAPI_GetVersion", #version) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string version = reaper.GU_GUtilitiesAPI_GetVersion()
(String versionOut, Int versionOut_sz) = GU_GUtilitiesAPI_GetVersion(versionOut, versionOut_sz)

Gets the current GUtilitiesAPI version

double GU_PCM_Source_GetSampleValue(PCM_source* source, double time)
double GU_PCM_Source_GetSampleValue(PCM_source source, time) (requires REAPER 6.24 or later)
double extension_api("GU_PCM_Source_GetSampleValue", PCM_source source, time) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.GU_PCM_Source_GetSampleValue(PCM_source source, number time)
Float GU_PCM_Source_GetSampleValue(PCM_source source, Float time)

Gets a PCM_source's sample value at a point in time (seconds)

bool GU_PCM_Source_HasRegion(PCM_source* source)
bool GU_PCM_Source_HasRegion(PCM_source source) (requires REAPER 6.24 or later)
bool extension_api("GU_PCM_Source_HasRegion", PCM_source source) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.GU_PCM_Source_HasRegion(PCM_source source)
Boolean GU_PCM_Source_HasRegion(PCM_source source)

Checks if PCM_source has embedded Media Cue Markers

bool GU_PCM_Source_IsMono(PCM_source* source)
bool GU_PCM_Source_IsMono(PCM_source source) (requires REAPER 6.24 or later)
bool extension_api("GU_PCM_Source_IsMono", PCM_source source) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.GU_PCM_Source_IsMono(PCM_source source)
Boolean GU_PCM_Source_IsMono(PCM_source source)

Checks if PCM_source is mono by comparing all channels

double GU_PCM_Source_TimeToPeak(PCM_source* source, int bufferSize, double threshold)
double GU_PCM_Source_TimeToPeak(PCM_source source, int bufferSize, threshold) (requires REAPER 6.24 or later)
double extension_api("GU_PCM_Source_TimeToPeak", PCM_source source, int bufferSize, threshold) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.GU_PCM_Source_TimeToPeak(PCM_source source, integer bufferSize, number threshold)
Float GU_PCM_Source_TimeToPeak(PCM_source source, Int bufferSize, Float threshold)

Returns duration in seconds for PCM_source from start til peak threshold is breached. Returns -1 if invalid

double GU_PCM_Source_TimeToPeakR(PCM_source* source, int bufferSize, double threshold)
double GU_PCM_Source_TimeToPeakR(PCM_source source, int bufferSize, threshold) (requires REAPER 6.24 or later)
double extension_api("GU_PCM_Source_TimeToPeakR", PCM_source source, int bufferSize, threshold) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.GU_PCM_Source_TimeToPeakR(PCM_source source, integer bufferSize, number threshold)
Float GU_PCM_Source_TimeToPeakR(PCM_source source, Int bufferSize, Float threshold)

Returns duration in seconds for PCM_source from end til peak threshold is breached in reverse. Returns -1 if invalid

double GU_PCM_Source_TimeToRMS(PCM_source* source, int bufferSize, double threshold)
double GU_PCM_Source_TimeToRMS(PCM_source source, int bufferSize, threshold) (requires REAPER 6.24 or later)
double extension_api("GU_PCM_Source_TimeToRMS", PCM_source source, int bufferSize, threshold) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.GU_PCM_Source_TimeToRMS(PCM_source source, integer bufferSize, number threshold)
Float GU_PCM_Source_TimeToRMS(PCM_source source, Int bufferSize, Float threshold)

Returns duration in seconds for PCM_source from start til RMS threshold is breached. Returns -1 if invalid

double GU_PCM_Source_TimeToRMSR(PCM_source* source, int bufferSize, double threshold)
double GU_PCM_Source_TimeToRMSR(PCM_source source, int bufferSize, threshold) (requires REAPER 6.24 or later)
double extension_api("GU_PCM_Source_TimeToRMSR", PCM_source source, int bufferSize, threshold) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.GU_PCM_Source_TimeToRMSR(PCM_source source, integer bufferSize, number threshold)
Float GU_PCM_Source_TimeToRMSR(PCM_source source, Int bufferSize, Float threshold)

Returns duration in seconds for PCM_source from end til RMS threshold is breached in reverse. Returns -1 if invalid

void GU_WildcardParseTake(MediaItem_Take* take, const char* input, char* valueOut, int valueOut_sz)
GU_WildcardParseTake(MediaItem_Take take, "input", #value) (requires REAPER 6.24 or later)
extension_api("GU_WildcardParseTake", MediaItem_Take take, "input", #value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string value = reaper.GU_WildcardParseTake(MediaItem_Take take, string input)
(MediaItem_Take take, String input, String valueOut, Int valueOut_sz) = GU_WildcardParseTake(take, input, valueOut, valueOut_sz)

Returns a string by parsing wildcards relative to the supplied MediaItem_Take

bool ImGui_AcceptDragDropPayload(ImGui_Context* ctx, const char* type, char* payloadOutNeedBig, int payloadOutNeedBig_sz, int* flagsInOptional)
bool ImGui_AcceptDragDropPayload(ImGui_Context ctx, "type", #payload, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_AcceptDragDropPayload", ImGui_Context ctx, "type", #payload, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string payload = reaper.ImGui_AcceptDragDropPayload(ImGui_Context ctx, string type, string payload, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String type, String payloadOutNeedBig, Int payloadOutNeedBig_sz, Int flagsInOptional) = ImGui_AcceptDragDropPayload(ctx, type, payloadOutNeedBig, payloadOutNeedBig_sz, flagsInOptional)

Accept contents of a given type. If DragDropFlags_AcceptBeforeDelivery is set
you can peek into the payload before the mouse button is released.

bool ImGui_AcceptDragDropPayloadFiles(ImGui_Context* ctx, int* countOut, int* flagsInOptional)
bool ImGui_AcceptDragDropPayloadFiles(ImGui_Context ctx, int &count, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_AcceptDragDropPayloadFiles", ImGui_Context ctx, int &count, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer count = reaper.ImGui_AcceptDragDropPayloadFiles(ImGui_Context ctx, integer count, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, Int countOut, Int flagsInOptional) = ImGui_AcceptDragDropPayloadFiles(ctx, countOut, flagsInOptional)

Accept a list of dropped files. See AcceptDragDropPayload and GetDragDropPayloadFile.

bool ImGui_AcceptDragDropPayloadRGB(ImGui_Context* ctx, int* rgbOut, int* flagsInOptional)
bool ImGui_AcceptDragDropPayloadRGB(ImGui_Context ctx, int &rgb, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_AcceptDragDropPayloadRGB", ImGui_Context ctx, int &rgb, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer rgb = reaper.ImGui_AcceptDragDropPayloadRGB(ImGui_Context ctx, integer rgb, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, Int rgbOut, Int flagsInOptional) = ImGui_AcceptDragDropPayloadRGB(ctx, rgbOut, flagsInOptional)

Accept a RGB color. See AcceptDragDropPayload.

bool ImGui_AcceptDragDropPayloadRGBA(ImGui_Context* ctx, int* rgbaOut, int* flagsInOptional)
bool ImGui_AcceptDragDropPayloadRGBA(ImGui_Context ctx, int &rgba, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_AcceptDragDropPayloadRGBA", ImGui_Context ctx, int &rgba, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer rgba = reaper.ImGui_AcceptDragDropPayloadRGBA(ImGui_Context ctx, integer rgba, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, Int rgbaOut, Int flagsInOptional) = ImGui_AcceptDragDropPayloadRGBA(ctx, rgbaOut, flagsInOptional)

Accept a RGBA color. See AcceptDragDropPayload.

void ImGui_AlignTextToFramePadding(ImGui_Context* ctx)
ImGui_AlignTextToFramePadding(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_AlignTextToFramePadding", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_AlignTextToFramePadding(ImGui_Context ctx)
ImGui_AlignTextToFramePadding(ImGui_Context ctx)

Vertically align upcoming text baseline to StyleVar_FramePadding.y so that it
will align properly to regularly framed items (call if you have text on a line
before a framed item).

bool ImGui_ArrowButton(ImGui_Context* ctx, const char* str_id, int dir)
bool ImGui_ArrowButton(ImGui_Context ctx, "str_id", int dir) (requires REAPER 6.24 or later)
bool extension_api("ImGui_ArrowButton", ImGui_Context ctx, "str_id", int dir) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_ArrowButton(ImGui_Context ctx, string str_id, integer dir)
Boolean ImGui_ArrowButton(ImGui_Context ctx, String str_id, Int dir)

Square button with an arrow shape. 'dir' is one of the Dir_* values

void ImGui_Attach(ImGui_Context* ctx, ImGui_Resource* obj)
ImGui_Attach(ImGui_Context ctx, ImGui_Resource obj) (requires REAPER 6.24 or later)
extension_api("ImGui_Attach", ImGui_Context ctx, ImGui_Resource obj) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Attach(ImGui_Context ctx, ImGui_Resource obj)
ImGui_Attach(ImGui_Context ctx, ImGui_Resource obj)

Link the object's lifetime to the given context.
Objects can be draw list splitters, fonts, images, list clippers, etc.
Call Detach to let the object be garbage-collected after unuse again.

List clipper objects may only be attached to the context they were created for.

Fonts are (currently) a special case: they must be attached to the context
before usage. Furthermore, fonts may only be attached or detached immediately
after the context is created or before any other function calls modifying the
context per defer cycle. See "limitations" in the font API documentation.

bool ImGui_Begin(ImGui_Context* ctx, const char* name, bool* p_openInOutOptional, int* flagsInOptional)
bool ImGui_Begin(ImGui_Context ctx, "name", optional bool &p_open, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_Begin", ImGui_Context ctx, "name", optional bool &p_open, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, optional boolean p_open = reaper.ImGui_Begin(ImGui_Context ctx, string name, optional boolean p_open, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String name, Boolean p_openInOutOptional, Int flagsInOptional) = ImGui_Begin(ctx, name, p_openInOutOptional, flagsInOptional)

Push window to the stack and start appending to it.

- Passing true to 'p_open' shows a window-closing widget in the upper-right
corner of the window, which clicking will set the boolean to false when returned.
- You may append multiple times to the same window during the same frame by
calling Begin()/End() pairs multiple times. Some information such as 'flags'
or 'p_open' will only be considered by the first call to Begin().
- Begin() return false to indicate the window is collapsed or fully clipped,
so you may early out and omit submitting anything to the window.

bool ImGui_BeginChild(ImGui_Context* ctx, const char* str_id, double* size_wInOptional, double* size_hInOptional, bool* borderInOptional, int* flagsInOptional)
bool ImGui_BeginChild(ImGui_Context ctx, "str_id", optional size_wIn, optional size_hIn, optional bool borderIn, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginChild", ImGui_Context ctx, "str_id", optional size_wIn, optional size_hIn, optional bool borderIn, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginChild(ImGui_Context ctx, string str_id, optional number size_wIn, optional number size_hIn, optional boolean borderIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String str_id, Float size_wInOptional, Float size_hInOptional, Boolean borderInOptional, Int flagsInOptional) = ImGui_BeginChild(ctx, str_id, size_wInOptional, size_hInOptional, borderInOptional, flagsInOptional)

For each independent axis of 'size':
- \> 0.0: fixed size
- = 0.0: use remaining host window size
- < 0.0: use remaining window size minus abs(size)
(Each axis can use a different mode, e.g. size = 0x400.)

Returns false to indicate the window is collapsed or fully clipped, so you may early out and omit submitting anything to the window.

bool ImGui_BeginChildFrame(ImGui_Context* ctx, const char* str_id, double size_w, double size_h, int* flagsInOptional)
bool ImGui_BeginChildFrame(ImGui_Context ctx, "str_id", size_w, size_h, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginChildFrame", ImGui_Context ctx, "str_id", size_w, size_h, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginChildFrame(ImGui_Context ctx, string str_id, number size_w, number size_h, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String str_id, Float size_w, Float size_h, Int flagsInOptional) = ImGui_BeginChildFrame(ctx, str_id, size_w, size_h, flagsInOptional)

Helper to create a child window / scrolling region that looks like a normal
widget frame. See BeginChild.

bool ImGui_BeginCombo(ImGui_Context* ctx, const char* label, const char* preview_value, int* flagsInOptional)
bool ImGui_BeginCombo(ImGui_Context ctx, "label", "preview_value", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginCombo", ImGui_Context ctx, "label", "preview_value", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginCombo(ImGui_Context ctx, string label, string preview_value, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, String preview_value, Int flagsInOptional) = ImGui_BeginCombo(ctx, label, preview_value, flagsInOptional)

The BeginCombo/EndCombo API allows you to manage your contents and selection
state however you want it, by creating e.g. Selectable items.

void ImGui_BeginDisabled(ImGui_Context* ctx, bool* disabledInOptional)
ImGui_BeginDisabled(ImGui_Context ctx, optional bool disabledIn) (requires REAPER 6.24 or later)
extension_api("ImGui_BeginDisabled", ImGui_Context ctx, optional bool disabledIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_BeginDisabled(ImGui_Context ctx, optional boolean disabledIn)
(ImGui_Context ctx, Boolean disabledInOptional) = ImGui_BeginDisabled(ctx, disabledInOptional)

Disable all user interactions and dim items visuals
(applying StyleVar_DisabledAlpha over current colors).

BeginDisabled(false) essentially does nothing useful but is provided to
facilitate use of boolean expressions.
If you can avoid calling BeginDisabled(false)/EndDisabled() best to avoid it.

bool ImGui_BeginDragDropSource(ImGui_Context* ctx, int* flagsInOptional)
bool ImGui_BeginDragDropSource(ImGui_Context ctx, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginDragDropSource", ImGui_Context ctx, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginDragDropSource(ImGui_Context ctx, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, Int flagsInOptional) = ImGui_BeginDragDropSource(ctx, flagsInOptional)

Call after submitting an item which may be dragged. when this return true,
you can call SetDragDropPayload() + EndDragDropSource()

If you stop calling BeginDragDropSource() the payload is preserved however
it won't have a preview tooltip (we currently display a fallback "..." tooltip
as replacement).

bool ImGui_BeginDragDropTarget(ImGui_Context* ctx)
bool ImGui_BeginDragDropTarget(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginDragDropTarget", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginDragDropTarget(ImGui_Context ctx)
Boolean ImGui_BeginDragDropTarget(ImGui_Context ctx)

Call after submitting an item that may receive a payload.
If this returns true, you can call AcceptDragDropPayload + EndDragDropTarget.

void ImGui_BeginGroup(ImGui_Context* ctx)
ImGui_BeginGroup(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_BeginGroup", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_BeginGroup(ImGui_Context ctx)
ImGui_BeginGroup(ImGui_Context ctx)

Lock horizontal starting position. See EndGroup.

bool ImGui_BeginListBox(ImGui_Context* ctx, const char* label, double* size_wInOptional, double* size_hInOptional)
bool ImGui_BeginListBox(ImGui_Context ctx, "label", optional size_wIn, optional size_hIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginListBox", ImGui_Context ctx, "label", optional size_wIn, optional size_hIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginListBox(ImGui_Context ctx, string label, optional number size_wIn, optional number size_hIn)
(Boolean retval, ImGui_Context ctx, String label, Float size_wInOptional, Float size_hInOptional) = ImGui_BeginListBox(ctx, label, size_wInOptional, size_hInOptional)

Open a framed scrolling region. This is essentially a thin wrapper to using
BeginChild/EndChild with some stylistic changes.

The BeginListBox/EndListBox API allows you to manage your contents and selection
state however you want it, by creating e.g. Selectable or any items.

- Choose frame width:
- width > 0.0: custom
- width < 0.0 or -FLT_MIN: right-align
- width = 0.0 (default): use current ItemWidth
- Choose frame height:
- height > 0.0: custom
- height < 0.0 or -FLT_MIN: bottom-align
- height = 0.0 (default): arbitrary default height which can fit ~7 items

See EndListBox.

bool ImGui_BeginMenu(ImGui_Context* ctx, const char* label, bool* enabledInOptional)
bool ImGui_BeginMenu(ImGui_Context ctx, "label", optional bool enabledIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginMenu", ImGui_Context ctx, "label", optional bool enabledIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginMenu(ImGui_Context ctx, string label, optional boolean enabledIn)
(Boolean retval, ImGui_Context ctx, String label, Boolean enabledInOptional) = ImGui_BeginMenu(ctx, label, enabledInOptional)

Create a sub-menu entry. only call EndMenu if this returns true!

bool ImGui_BeginMenuBar(ImGui_Context* ctx)
bool ImGui_BeginMenuBar(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginMenuBar", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginMenuBar(ImGui_Context ctx)
Boolean ImGui_BeginMenuBar(ImGui_Context ctx)

Append to menu-bar of current window (requires WindowFlags_MenuBar flag set
on parent window). See EndMenuBar.

bool ImGui_BeginPopup(ImGui_Context* ctx, const char* str_id, int* flagsInOptional)
bool ImGui_BeginPopup(ImGui_Context ctx, "str_id", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginPopup", ImGui_Context ctx, "str_id", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginPopup(ImGui_Context ctx, string str_id, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String str_id, Int flagsInOptional) = ImGui_BeginPopup(ctx, str_id, flagsInOptional)

Query popup state, if open start appending into the window. Call EndPopup
afterwards. WindowFlags* are forwarded to the window.

Return true if the popup is open, and you can start outputting to it.

bool ImGui_BeginPopupContextItem(ImGui_Context* ctx, const char* str_idInOptional, int* popup_flagsInOptional)
bool ImGui_BeginPopupContextItem(ImGui_Context ctx, optional "str_idIn", optional int popup_flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginPopupContextItem", ImGui_Context ctx, optional "str_idIn", optional int popup_flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginPopupContextItem(ImGui_Context ctx, optional string str_idIn, optional integer popup_flagsIn)
(Boolean retval, ImGui_Context ctx, String str_idInOptional, Int popup_flagsInOptional) = ImGui_BeginPopupContextItem(ctx, str_idInOptional, popup_flagsInOptional)

This is a helper to handle the simplest case of associating one named popup
to one given widget. You can pass a nil str_id to use the identifier of the last
item. This is essentially the same as calling OpenPopupOnItemClick + BeginPopup
but written to avoid computing the ID twice because BeginPopupContext*
functions may be called very frequently.

If you want to use that on a non-interactive item such as Text you need to pass
in an explicit ID here.

bool ImGui_BeginPopupContextWindow(ImGui_Context* ctx, const char* str_idInOptional, int* popup_flagsInOptional)
bool ImGui_BeginPopupContextWindow(ImGui_Context ctx, optional "str_idIn", optional int popup_flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginPopupContextWindow", ImGui_Context ctx, optional "str_idIn", optional int popup_flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginPopupContextWindow(ImGui_Context ctx, optional string str_idIn, optional integer popup_flagsIn)
(Boolean retval, ImGui_Context ctx, String str_idInOptional, Int popup_flagsInOptional) = ImGui_BeginPopupContextWindow(ctx, str_idInOptional, popup_flagsInOptional)

Open+begin popup when clicked on current window.

bool ImGui_BeginPopupModal(ImGui_Context* ctx, const char* name, bool* p_openInOutOptional, int* flagsInOptional)
bool ImGui_BeginPopupModal(ImGui_Context ctx, "name", optional bool &p_open, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginPopupModal", ImGui_Context ctx, "name", optional bool &p_open, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, optional boolean p_open = reaper.ImGui_BeginPopupModal(ImGui_Context ctx, string name, optional boolean p_open, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String name, Boolean p_openInOutOptional, Int flagsInOptional) = ImGui_BeginPopupModal(ctx, name, p_openInOutOptional, flagsInOptional)

Block every interaction behind the window, cannot be closed by user, add a
dimming background, has a title bar. Return true if the modal is open, and you
can start outputting to it. See BeginPopup.

bool ImGui_BeginTabBar(ImGui_Context* ctx, const char* str_id, int* flagsInOptional)
bool ImGui_BeginTabBar(ImGui_Context ctx, "str_id", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginTabBar", ImGui_Context ctx, "str_id", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginTabBar(ImGui_Context ctx, string str_id, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String str_id, Int flagsInOptional) = ImGui_BeginTabBar(ctx, str_id, flagsInOptional)

Create and append into a TabBar.

bool ImGui_BeginTabItem(ImGui_Context* ctx, const char* label, bool* p_openInOutOptional, int* flagsInOptional)
bool ImGui_BeginTabItem(ImGui_Context ctx, "label", optional bool &p_open, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginTabItem", ImGui_Context ctx, "label", optional bool &p_open, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, optional boolean p_open = reaper.ImGui_BeginTabItem(ImGui_Context ctx, string label, optional boolean p_open, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Boolean p_openInOutOptional, Int flagsInOptional) = ImGui_BeginTabItem(ctx, label, p_openInOutOptional, flagsInOptional)

Create a Tab. Returns true if the Tab is selected.
Set 'p_open' to true to enable the close button.

bool ImGui_BeginTable(ImGui_Context* ctx, const char* str_id, int column, int* flagsInOptional, double* outer_size_wInOptional, double* outer_size_hInOptional, double* inner_widthInOptional)
bool ImGui_BeginTable(ImGui_Context ctx, "str_id", int column, optional int flagsIn, optional outer_size_wIn, optional outer_size_hIn, optional inner_widthIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginTable", ImGui_Context ctx, "str_id", int column, optional int flagsIn, optional outer_size_wIn, optional outer_size_hIn, optional inner_widthIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginTable(ImGui_Context ctx, string str_id, integer column, optional integer flagsIn, optional number outer_size_wIn, optional number outer_size_hIn, optional number inner_widthIn)
(Boolean retval, ImGui_Context ctx, String str_id, Int column, Int flagsInOptional, Float outer_size_wInOptional, Float outer_size_hInOptional, Float inner_widthInOptional) = ImGui_BeginTable(ctx, str_id, column, flagsInOptional, outer_size_wInOptional, outer_size_hInOptional, inner_widthInOptional)
bool ImGui_BeginTooltip(ImGui_Context* ctx)
bool ImGui_BeginTooltip(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_BeginTooltip", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_BeginTooltip(ImGui_Context ctx)
Boolean ImGui_BeginTooltip(ImGui_Context ctx)

Begin/append a tooltip window.
To create full-featured tooltip (with any kind of items).

void ImGui_Bullet(ImGui_Context* ctx)
ImGui_Bullet(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_Bullet", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Bullet(ImGui_Context ctx)
ImGui_Bullet(ImGui_Context ctx)

Draw a small circle + keep the cursor on the same line.
Advance cursor x position by GetTreeNodeToLabelSpacing,
same distance that TreeNode uses.

void ImGui_BulletText(ImGui_Context* ctx, const char* text)
ImGui_BulletText(ImGui_Context ctx, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_BulletText", ImGui_Context ctx, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_BulletText(ImGui_Context ctx, string text)
ImGui_BulletText(ImGui_Context ctx, String text)

Shortcut for Bullet + Text.

bool ImGui_Button(ImGui_Context* ctx, const char* label, double* size_wInOptional, double* size_hInOptional)
bool ImGui_Button(ImGui_Context ctx, "label", optional size_wIn, optional size_hIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_Button", ImGui_Context ctx, "label", optional size_wIn, optional size_hIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_Button(ImGui_Context ctx, string label, optional number size_wIn, optional number size_hIn)
(Boolean retval, ImGui_Context ctx, String label, Float size_wInOptional, Float size_hInOptional) = ImGui_Button(ctx, label, size_wInOptional, size_hInOptional)
int ImGui_ButtonFlags_MouseButtonLeft()
int ImGui_ButtonFlags_MouseButtonLeft() (requires REAPER 6.24 or later)
int extension_api("ImGui_ButtonFlags_MouseButtonLeft") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ButtonFlags_MouseButtonLeft()
Int ImGui_ButtonFlags_MouseButtonLeft()

React on left mouse button (default).

int ImGui_ButtonFlags_MouseButtonMiddle()
int ImGui_ButtonFlags_MouseButtonMiddle() (requires REAPER 6.24 or later)
int extension_api("ImGui_ButtonFlags_MouseButtonMiddle") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ButtonFlags_MouseButtonMiddle()
Int ImGui_ButtonFlags_MouseButtonMiddle()

React on center mouse button.

int ImGui_ButtonFlags_MouseButtonRight()
int ImGui_ButtonFlags_MouseButtonRight() (requires REAPER 6.24 or later)
int extension_api("ImGui_ButtonFlags_MouseButtonRight") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ButtonFlags_MouseButtonRight()
Int ImGui_ButtonFlags_MouseButtonRight()

React on right mouse button.

int ImGui_ButtonFlags_None()
int ImGui_ButtonFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_ButtonFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ButtonFlags_None()
Int ImGui_ButtonFlags_None()
double ImGui_CalcItemWidth(ImGui_Context* ctx)
double ImGui_CalcItemWidth(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_CalcItemWidth", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_CalcItemWidth(ImGui_Context ctx)
Float ImGui_CalcItemWidth(ImGui_Context ctx)

Width of item given pushed settings and current cursor position.
NOT necessarily the width of last item unlike most 'Item' functions.

void ImGui_CalcTextSize(ImGui_Context* ctx, const char* text, double* wOut, double* hOut, bool* hide_text_after_double_hashInOptional, double* wrap_widthInOptional)
ImGui_CalcTextSize(ImGui_Context ctx, "text", &w, &h, optional bool hide_text_after_double_hashIn, optional wrap_widthIn) (requires REAPER 6.24 or later)
extension_api("ImGui_CalcTextSize", ImGui_Context ctx, "text", &w, &h, optional bool hide_text_after_double_hashIn, optional wrap_widthIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number w, number h = reaper.ImGui_CalcTextSize(ImGui_Context ctx, string text, number w, number h, optional boolean hide_text_after_double_hashIn, optional number wrap_widthIn)
(ImGui_Context ctx, String text, Float wOut, Float hOut, Boolean hide_text_after_double_hashInOptional, Float wrap_widthInOptional) = ImGui_CalcTextSize(ctx, text, wOut, hOut, hide_text_after_double_hashInOptional, wrap_widthInOptional)
bool ImGui_Checkbox(ImGui_Context* ctx, const char* label, bool* vInOut)
bool ImGui_Checkbox(ImGui_Context ctx, "label", bool &v) (requires REAPER 6.24 or later)
bool extension_api("ImGui_Checkbox", ImGui_Context ctx, "label", bool &v) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, boolean v = reaper.ImGui_Checkbox(ImGui_Context ctx, string label, boolean v)
(Boolean retval, ImGui_Context ctx, String label, Boolean vInOut) = ImGui_Checkbox(ctx, label, vInOut)
bool ImGui_CheckboxFlags(ImGui_Context* ctx, const char* label, int* flagsInOut, int flags_value)
bool ImGui_CheckboxFlags(ImGui_Context ctx, "label", int &flags, int flags_value) (requires REAPER 6.24 or later)
bool extension_api("ImGui_CheckboxFlags", ImGui_Context ctx, "label", int &flags, int flags_value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer flags = reaper.ImGui_CheckboxFlags(ImGui_Context ctx, string label, integer flags, integer flags_value)
(Boolean retval, ImGui_Context ctx, String label, Int flagsInOut, Int flags_value) = ImGui_CheckboxFlags(ctx, label, flagsInOut, flags_value)
void ImGui_CloseCurrentPopup(ImGui_Context* ctx)
ImGui_CloseCurrentPopup(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_CloseCurrentPopup", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_CloseCurrentPopup(ImGui_Context ctx)
ImGui_CloseCurrentPopup(ImGui_Context ctx)

Manually close the popup we have begin-ed into.
Use inside the BeginPopup/EndPopup scope to close manually.

CloseCurrentPopup() is called by default by Selectable/MenuItem when activated.

int ImGui_Col_Border()
int ImGui_Col_Border() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_Border") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_Border()
Int ImGui_Col_Border()
int ImGui_Col_BorderShadow()
int ImGui_Col_BorderShadow() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_BorderShadow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_BorderShadow()
Int ImGui_Col_BorderShadow()
int ImGui_Col_Button()
int ImGui_Col_Button() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_Button") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_Button()
Int ImGui_Col_Button()
int ImGui_Col_ButtonActive()
int ImGui_Col_ButtonActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ButtonActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ButtonActive()
Int ImGui_Col_ButtonActive()
int ImGui_Col_ButtonHovered()
int ImGui_Col_ButtonHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ButtonHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ButtonHovered()
Int ImGui_Col_ButtonHovered()
int ImGui_Col_CheckMark()
int ImGui_Col_CheckMark() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_CheckMark") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_CheckMark()
Int ImGui_Col_CheckMark()
int ImGui_Col_ChildBg()
int ImGui_Col_ChildBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ChildBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ChildBg()
Int ImGui_Col_ChildBg()

Background of child windows.

int ImGui_Col_DockingEmptyBg()
int ImGui_Col_DockingEmptyBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_DockingEmptyBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_DockingEmptyBg()
Int ImGui_Col_DockingEmptyBg()

Background color for empty node (e.g. CentralNode with no window docked into it).

int ImGui_Col_DockingPreview()
int ImGui_Col_DockingPreview() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_DockingPreview") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_DockingPreview()
Int ImGui_Col_DockingPreview()

Preview overlay color when about to docking something.

int ImGui_Col_DragDropTarget()
int ImGui_Col_DragDropTarget() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_DragDropTarget") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_DragDropTarget()
Int ImGui_Col_DragDropTarget()

Rectangle highlighting a drop target

int ImGui_Col_FrameBg()
int ImGui_Col_FrameBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_FrameBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_FrameBg()
Int ImGui_Col_FrameBg()

Background of checkbox, radio button, plot, slider, text input.

int ImGui_Col_FrameBgActive()
int ImGui_Col_FrameBgActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_FrameBgActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_FrameBgActive()
Int ImGui_Col_FrameBgActive()
int ImGui_Col_FrameBgHovered()
int ImGui_Col_FrameBgHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_FrameBgHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_FrameBgHovered()
Int ImGui_Col_FrameBgHovered()
int ImGui_Col_Header()
int ImGui_Col_Header() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_Header") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_Header()
Int ImGui_Col_Header()

Header* colors are used for CollapsingHeader, TreeNode, Selectable, MenuItem.

int ImGui_Col_HeaderActive()
int ImGui_Col_HeaderActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_HeaderActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_HeaderActive()
Int ImGui_Col_HeaderActive()
int ImGui_Col_HeaderHovered()
int ImGui_Col_HeaderHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_HeaderHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_HeaderHovered()
Int ImGui_Col_HeaderHovered()
int ImGui_Col_MenuBarBg()
int ImGui_Col_MenuBarBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_MenuBarBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_MenuBarBg()
Int ImGui_Col_MenuBarBg()
int ImGui_Col_ModalWindowDimBg()
int ImGui_Col_ModalWindowDimBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ModalWindowDimBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ModalWindowDimBg()
Int ImGui_Col_ModalWindowDimBg()

Darken/colorize entire screen behind a modal window, when one is active.

int ImGui_Col_NavHighlight()
int ImGui_Col_NavHighlight() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_NavHighlight") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_NavHighlight()
Int ImGui_Col_NavHighlight()

Gamepad/keyboard: current highlighted item.

int ImGui_Col_NavWindowingDimBg()
int ImGui_Col_NavWindowingDimBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_NavWindowingDimBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_NavWindowingDimBg()
Int ImGui_Col_NavWindowingDimBg()

Darken/colorize entire screen behind the CTRL+TAB window list, when active.

int ImGui_Col_NavWindowingHighlight()
int ImGui_Col_NavWindowingHighlight() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_NavWindowingHighlight") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_NavWindowingHighlight()
Int ImGui_Col_NavWindowingHighlight()

Highlight window when using CTRL+TAB.

int ImGui_Col_PlotHistogram()
int ImGui_Col_PlotHistogram() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_PlotHistogram") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_PlotHistogram()
Int ImGui_Col_PlotHistogram()
int ImGui_Col_PlotHistogramHovered()
int ImGui_Col_PlotHistogramHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_PlotHistogramHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_PlotHistogramHovered()
Int ImGui_Col_PlotHistogramHovered()
int ImGui_Col_PlotLines()
int ImGui_Col_PlotLines() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_PlotLines") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_PlotLines()
Int ImGui_Col_PlotLines()
int ImGui_Col_PlotLinesHovered()
int ImGui_Col_PlotLinesHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_PlotLinesHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_PlotLinesHovered()
Int ImGui_Col_PlotLinesHovered()
int ImGui_Col_PopupBg()
int ImGui_Col_PopupBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_PopupBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_PopupBg()
Int ImGui_Col_PopupBg()

Background of popups, menus, tooltips windows.

int ImGui_Col_ResizeGrip()
int ImGui_Col_ResizeGrip() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ResizeGrip") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ResizeGrip()
Int ImGui_Col_ResizeGrip()

Resize grip in lower-right and lower-left corners of windows.

int ImGui_Col_ResizeGripActive()
int ImGui_Col_ResizeGripActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ResizeGripActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ResizeGripActive()
Int ImGui_Col_ResizeGripActive()
int ImGui_Col_ResizeGripHovered()
int ImGui_Col_ResizeGripHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ResizeGripHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ResizeGripHovered()
Int ImGui_Col_ResizeGripHovered()
int ImGui_Col_ScrollbarBg()
int ImGui_Col_ScrollbarBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ScrollbarBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ScrollbarBg()
Int ImGui_Col_ScrollbarBg()
int ImGui_Col_ScrollbarGrab()
int ImGui_Col_ScrollbarGrab() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ScrollbarGrab") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ScrollbarGrab()
Int ImGui_Col_ScrollbarGrab()
int ImGui_Col_ScrollbarGrabActive()
int ImGui_Col_ScrollbarGrabActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ScrollbarGrabActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ScrollbarGrabActive()
Int ImGui_Col_ScrollbarGrabActive()
int ImGui_Col_ScrollbarGrabHovered()
int ImGui_Col_ScrollbarGrabHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_ScrollbarGrabHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_ScrollbarGrabHovered()
Int ImGui_Col_ScrollbarGrabHovered()
int ImGui_Col_Separator()
int ImGui_Col_Separator() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_Separator") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_Separator()
Int ImGui_Col_Separator()
int ImGui_Col_SeparatorActive()
int ImGui_Col_SeparatorActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_SeparatorActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_SeparatorActive()
Int ImGui_Col_SeparatorActive()
int ImGui_Col_SeparatorHovered()
int ImGui_Col_SeparatorHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_SeparatorHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_SeparatorHovered()
Int ImGui_Col_SeparatorHovered()
int ImGui_Col_SliderGrab()
int ImGui_Col_SliderGrab() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_SliderGrab") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_SliderGrab()
Int ImGui_Col_SliderGrab()
int ImGui_Col_SliderGrabActive()
int ImGui_Col_SliderGrabActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_SliderGrabActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_SliderGrabActive()
Int ImGui_Col_SliderGrabActive()
int ImGui_Col_Tab()
int ImGui_Col_Tab() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_Tab") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_Tab()
Int ImGui_Col_Tab()

TabItem in a TabBar

int ImGui_Col_TabActive()
int ImGui_Col_TabActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TabActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TabActive()
Int ImGui_Col_TabActive()
int ImGui_Col_TabHovered()
int ImGui_Col_TabHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TabHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TabHovered()
Int ImGui_Col_TabHovered()
int ImGui_Col_TabUnfocused()
int ImGui_Col_TabUnfocused() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TabUnfocused") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TabUnfocused()
Int ImGui_Col_TabUnfocused()
int ImGui_Col_TabUnfocusedActive()
int ImGui_Col_TabUnfocusedActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TabUnfocusedActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TabUnfocusedActive()
Int ImGui_Col_TabUnfocusedActive()
int ImGui_Col_TableBorderLight()
int ImGui_Col_TableBorderLight() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TableBorderLight") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TableBorderLight()
Int ImGui_Col_TableBorderLight()

Table inner borders (prefer using Alpha=1.0 here).

int ImGui_Col_TableBorderStrong()
int ImGui_Col_TableBorderStrong() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TableBorderStrong") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TableBorderStrong()
Int ImGui_Col_TableBorderStrong()

Table outer and header borders (prefer using Alpha=1.0 here).

int ImGui_Col_TableHeaderBg()
int ImGui_Col_TableHeaderBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TableHeaderBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TableHeaderBg()
Int ImGui_Col_TableHeaderBg()

Table header background.

int ImGui_Col_TableRowBg()
int ImGui_Col_TableRowBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TableRowBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TableRowBg()
Int ImGui_Col_TableRowBg()

Table row background (even rows).

int ImGui_Col_TableRowBgAlt()
int ImGui_Col_TableRowBgAlt() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TableRowBgAlt") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TableRowBgAlt()
Int ImGui_Col_TableRowBgAlt()

Table row background (odd rows).

int ImGui_Col_Text()
int ImGui_Col_Text() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_Text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_Text()
Int ImGui_Col_Text()
int ImGui_Col_TextDisabled()
int ImGui_Col_TextDisabled() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TextDisabled") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TextDisabled()
Int ImGui_Col_TextDisabled()
int ImGui_Col_TextSelectedBg()
int ImGui_Col_TextSelectedBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TextSelectedBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TextSelectedBg()
Int ImGui_Col_TextSelectedBg()
int ImGui_Col_TitleBg()
int ImGui_Col_TitleBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TitleBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TitleBg()
Int ImGui_Col_TitleBg()
int ImGui_Col_TitleBgActive()
int ImGui_Col_TitleBgActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TitleBgActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TitleBgActive()
Int ImGui_Col_TitleBgActive()
int ImGui_Col_TitleBgCollapsed()
int ImGui_Col_TitleBgCollapsed() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_TitleBgCollapsed") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_TitleBgCollapsed()
Int ImGui_Col_TitleBgCollapsed()
int ImGui_Col_WindowBg()
int ImGui_Col_WindowBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_Col_WindowBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Col_WindowBg()
Int ImGui_Col_WindowBg()

Background of normal windows. See also WindowFlags_NoBackground.

bool ImGui_CollapsingHeader(ImGui_Context* ctx, const char* label, bool* p_visibleInOut, int* flagsInOptional)
bool ImGui_CollapsingHeader(ImGui_Context ctx, "label", bool &p_visible, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_CollapsingHeader", ImGui_Context ctx, "label", bool &p_visible, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, boolean p_visible = reaper.ImGui_CollapsingHeader(ImGui_Context ctx, string label, boolean p_visible, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Boolean p_visibleInOut, Int flagsInOptional) = ImGui_CollapsingHeader(ctx, label, p_visibleInOut, flagsInOptional)

Returns true when opened but do not indent nor push into the ID stack
(because of the TreeNodeFlags_NoTreePushOnOpen flag).

This is basically the same as calling TreeNode(label, TreeNodeFlags_CollapsingHeader).
You can remove the _NoTreePushOnOpen flag if you want behavior closer to normal
TreeNode.

When 'visible' is provided: if 'true' display an additional small close button
on upper right of the header which will set the bool to false when clicked,
if 'false' don't display the header.

bool ImGui_ColorButton(ImGui_Context* ctx, const char* desc_id, int col_rgba, int* flagsInOptional, double* size_wInOptional, double* size_hInOptional)
bool ImGui_ColorButton(ImGui_Context ctx, "desc_id", int col_rgba, optional int flagsIn, optional size_wIn, optional size_hIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_ColorButton", ImGui_Context ctx, "desc_id", int col_rgba, optional int flagsIn, optional size_wIn, optional size_hIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_ColorButton(ImGui_Context ctx, string desc_id, integer col_rgba, optional integer flagsIn, optional number size_wIn, optional number size_hIn)
(Boolean retval, ImGui_Context ctx, String desc_id, Int col_rgba, Int flagsInOptional, Float size_wInOptional, Float size_hInOptional) = ImGui_ColorButton(ctx, desc_id, col_rgba, flagsInOptional, size_wInOptional, size_hInOptional)

Display a color square/button, hover for details, return true when pressed.
Color is in 0xRRGGBBAA or, if ColorEditFlags_NoAlpha is set, 0xRRGGBB.

int ImGui_ColorConvertDouble4ToU32(double r, double g, double b, double a)
int ImGui_ColorConvertDouble4ToU32(r, g, b, a) (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorConvertDouble4ToU32", r, g, b, a) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorConvertDouble4ToU32(number r, number g, number b, number a)
Int ImGui_ColorConvertDouble4ToU32(Float r, Float g, Float b, Float a)

Pack 0..1 RGBA values into a 32-bit integer (0xRRGGBBAA).

void ImGui_ColorConvertHSVtoRGB(double h, double s, double v, double* rOut, double* gOut, double* bOut)
ImGui_ColorConvertHSVtoRGB(h, s, v, &r, &g, &b) (requires REAPER 6.24 or later)
extension_api("ImGui_ColorConvertHSVtoRGB", h, s, v, &r, &g, &b) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number r, number g, number b = reaper.ImGui_ColorConvertHSVtoRGB(number h, number s, number v)
(Float h, Float s, Float v, Float rOut, Float gOut, Float bOut) = ImGui_ColorConvertHSVtoRGB(h, s, v, rOut, gOut, bOut)

Convert HSV values (0..1) into RGB (0..1).

int ImGui_ColorConvertNative(int rgb)
int ImGui_ColorConvertNative(int rgb) (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorConvertNative", int rgb) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorConvertNative(integer rgb)
Int ImGui_ColorConvertNative(Int rgb)

Convert a native color coming from REAPER or 0xRRGGBB to native.
This swaps the red and blue channels on Windows.

void ImGui_ColorConvertRGBtoHSV(double r, double g, double b, double* hOut, double* sOut, double* vOut)
ImGui_ColorConvertRGBtoHSV(r, g, b, &h, &s, &v) (requires REAPER 6.24 or later)
extension_api("ImGui_ColorConvertRGBtoHSV", r, g, b, &h, &s, &v) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number h, number s, number v = reaper.ImGui_ColorConvertRGBtoHSV(number r, number g, number b)
(Float r, Float g, Float b, Float hOut, Float sOut, Float vOut) = ImGui_ColorConvertRGBtoHSV(r, g, b, hOut, sOut, vOut)

Convert RGB values (0..1) into HSV (0..1).

void ImGui_ColorConvertU32ToDouble4(int rgba, double* rOut, double* gOut, double* bOut, double* aOut)
ImGui_ColorConvertU32ToDouble4(int rgba, &r, &g, &b, &a) (requires REAPER 6.24 or later)
extension_api("ImGui_ColorConvertU32ToDouble4", int rgba, &r, &g, &b, &a) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number r, number g, number b, number a = reaper.ImGui_ColorConvertU32ToDouble4(integer rgba)
(Int rgba, Float rOut, Float gOut, Float bOut, Float aOut) = ImGui_ColorConvertU32ToDouble4(rgba, rOut, gOut, bOut, aOut)

Unpack a 32-bit integer (0xRRGGBBAA) into separate RGBA values (0..1).

bool ImGui_ColorEdit3(ImGui_Context* ctx, const char* label, int* col_rgbInOut, int* flagsInOptional)
bool ImGui_ColorEdit3(ImGui_Context ctx, "label", int &col_rgb, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_ColorEdit3", ImGui_Context ctx, "label", int &col_rgb, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer col_rgb = reaper.ImGui_ColorEdit3(ImGui_Context ctx, string label, integer col_rgb, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int col_rgbInOut, Int flagsInOptional) = ImGui_ColorEdit3(ctx, label, col_rgbInOut, flagsInOptional)

Color is in 0xXXRRGGBB. XX is ignored and will not be modified.

bool ImGui_ColorEdit4(ImGui_Context* ctx, const char* label, int* col_rgbaInOut, int* flagsInOptional)
bool ImGui_ColorEdit4(ImGui_Context ctx, "label", int &col_rgba, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_ColorEdit4", ImGui_Context ctx, "label", int &col_rgba, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer col_rgba = reaper.ImGui_ColorEdit4(ImGui_Context ctx, string label, integer col_rgba, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int col_rgbaInOut, Int flagsInOptional) = ImGui_ColorEdit4(ctx, label, col_rgbaInOut, flagsInOptional)

Color is in 0xRRGGBBAA or, if ColorEditFlags_NoAlpha is set, 0xXXRRGGBB
(XX is ignored and will not be modified).

int ImGui_ColorEditFlags_AlphaBar()
int ImGui_ColorEditFlags_AlphaBar() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_AlphaBar") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_AlphaBar()
Int ImGui_ColorEditFlags_AlphaBar()

ColorEdit, ColorPicker: show vertical alpha bar/gradient in picker.

int ImGui_ColorEditFlags_AlphaPreview()
int ImGui_ColorEditFlags_AlphaPreview() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_AlphaPreview") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_AlphaPreview()
Int ImGui_ColorEditFlags_AlphaPreview()

ColorEdit, ColorPicker, ColorButton: display preview as a transparent color
over a checkerboard, instead of opaque.

int ImGui_ColorEditFlags_AlphaPreviewHalf()
int ImGui_ColorEditFlags_AlphaPreviewHalf() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_AlphaPreviewHalf") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_AlphaPreviewHalf()
Int ImGui_ColorEditFlags_AlphaPreviewHalf()

ColorEdit, ColorPicker, ColorButton: display half opaque / half checkerboard,
instead of opaque.

int ImGui_ColorEditFlags_DisplayHSV()
int ImGui_ColorEditFlags_DisplayHSV() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_DisplayHSV") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_DisplayHSV()
Int ImGui_ColorEditFlags_DisplayHSV()

ColorEdit: override _display_ type to HSV. ColorPicker:
select any combination using one or more of RGB/HSV/Hex.

int ImGui_ColorEditFlags_DisplayHex()
int ImGui_ColorEditFlags_DisplayHex() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_DisplayHex") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_DisplayHex()
Int ImGui_ColorEditFlags_DisplayHex()

ColorEdit: override _display_ type to Hex. ColorPicker:
select any combination using one or more of RGB/HSV/Hex.

int ImGui_ColorEditFlags_DisplayRGB()
int ImGui_ColorEditFlags_DisplayRGB() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_DisplayRGB") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_DisplayRGB()
Int ImGui_ColorEditFlags_DisplayRGB()

ColorEdit: override _display_ type to RGB. ColorPicker:
select any combination using one or more of RGB/HSV/Hex.

int ImGui_ColorEditFlags_Float()
int ImGui_ColorEditFlags_Float() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_Float") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_Float()
Int ImGui_ColorEditFlags_Float()

ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0.0..1.0
floats instead of 0..255 integers. No round-trip of value via integers.

int ImGui_ColorEditFlags_InputHSV()
int ImGui_ColorEditFlags_InputHSV() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_InputHSV") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_InputHSV()
Int ImGui_ColorEditFlags_InputHSV()

ColorEdit, ColorPicker: input and output data in HSV format.

int ImGui_ColorEditFlags_InputRGB()
int ImGui_ColorEditFlags_InputRGB() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_InputRGB") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_InputRGB()
Int ImGui_ColorEditFlags_InputRGB()

ColorEdit, ColorPicker: input and output data in RGB format.

int ImGui_ColorEditFlags_NoAlpha()
int ImGui_ColorEditFlags_NoAlpha() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoAlpha") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoAlpha()
Int ImGui_ColorEditFlags_NoAlpha()

ColorEdit, ColorPicker, ColorButton: ignore Alpha component
(will only read 3 components from the input pointer).

int ImGui_ColorEditFlags_NoBorder()
int ImGui_ColorEditFlags_NoBorder() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoBorder") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoBorder()
Int ImGui_ColorEditFlags_NoBorder()

ColorButton: disable border (which is enforced by default).

int ImGui_ColorEditFlags_NoDragDrop()
int ImGui_ColorEditFlags_NoDragDrop() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoDragDrop") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoDragDrop()
Int ImGui_ColorEditFlags_NoDragDrop()

ColorEdit: disable drag and drop target. ColorButton: disable drag and drop source.

int ImGui_ColorEditFlags_NoInputs()
int ImGui_ColorEditFlags_NoInputs() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoInputs") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoInputs()
Int ImGui_ColorEditFlags_NoInputs()

ColorEdit, ColorPicker: disable inputs sliders/text widgets
(e.g. to show only the small preview color square).

int ImGui_ColorEditFlags_NoLabel()
int ImGui_ColorEditFlags_NoLabel() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoLabel") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoLabel()
Int ImGui_ColorEditFlags_NoLabel()

ColorEdit, ColorPicker: disable display of inline text label
(the label is still forwarded to the tooltip and picker).

int ImGui_ColorEditFlags_NoOptions()
int ImGui_ColorEditFlags_NoOptions() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoOptions") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoOptions()
Int ImGui_ColorEditFlags_NoOptions()

ColorEdit: disable toggling options menu when right-clicking on inputs/small preview.

int ImGui_ColorEditFlags_NoPicker()
int ImGui_ColorEditFlags_NoPicker() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoPicker") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoPicker()
Int ImGui_ColorEditFlags_NoPicker()

ColorEdit: disable picker when clicking on color square.

int ImGui_ColorEditFlags_NoSidePreview()
int ImGui_ColorEditFlags_NoSidePreview() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoSidePreview") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoSidePreview()
Int ImGui_ColorEditFlags_NoSidePreview()

ColorPicker: disable bigger color preview on right side of the picker,
use small color square preview instead.

int ImGui_ColorEditFlags_NoSmallPreview()
int ImGui_ColorEditFlags_NoSmallPreview() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoSmallPreview") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoSmallPreview()
Int ImGui_ColorEditFlags_NoSmallPreview()

ColorEdit, ColorPicker: disable color square preview next to the inputs.
(e.g. to show only the inputs).

int ImGui_ColorEditFlags_NoTooltip()
int ImGui_ColorEditFlags_NoTooltip() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_NoTooltip") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_NoTooltip()
Int ImGui_ColorEditFlags_NoTooltip()

ColorEdit, ColorPicker, ColorButton: disable tooltip when hovering the preview.

int ImGui_ColorEditFlags_None()
int ImGui_ColorEditFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_None()
Int ImGui_ColorEditFlags_None()
int ImGui_ColorEditFlags_PickerHueBar()
int ImGui_ColorEditFlags_PickerHueBar() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_PickerHueBar") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_PickerHueBar()
Int ImGui_ColorEditFlags_PickerHueBar()

ColorPicker: bar for Hue, rectangle for Sat/Value.

int ImGui_ColorEditFlags_PickerHueWheel()
int ImGui_ColorEditFlags_PickerHueWheel() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_PickerHueWheel") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_PickerHueWheel()
Int ImGui_ColorEditFlags_PickerHueWheel()

ColorPicker: wheel for Hue, triangle for Sat/Value.

int ImGui_ColorEditFlags_Uint8()
int ImGui_ColorEditFlags_Uint8() (requires REAPER 6.24 or later)
int extension_api("ImGui_ColorEditFlags_Uint8") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ColorEditFlags_Uint8()
Int ImGui_ColorEditFlags_Uint8()

ColorEdit, ColorPicker, ColorButton: _display_ values formatted as 0..255.

bool ImGui_ColorPicker3(ImGui_Context* ctx, const char* label, int* col_rgbInOut, int* flagsInOptional)
bool ImGui_ColorPicker3(ImGui_Context ctx, "label", int &col_rgb, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_ColorPicker3", ImGui_Context ctx, "label", int &col_rgb, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer col_rgb = reaper.ImGui_ColorPicker3(ImGui_Context ctx, string label, integer col_rgb, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int col_rgbInOut, Int flagsInOptional) = ImGui_ColorPicker3(ctx, label, col_rgbInOut, flagsInOptional)

Color is in 0xXXRRGGBB. XX is ignored and will not be modified.

bool ImGui_ColorPicker4(ImGui_Context* ctx, const char* label, int* col_rgbaInOut, int* flagsInOptional, int* ref_colInOptional)
bool ImGui_ColorPicker4(ImGui_Context ctx, "label", int &col_rgba, optional int flagsIn, optional int ref_colIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_ColorPicker4", ImGui_Context ctx, "label", int &col_rgba, optional int flagsIn, optional int ref_colIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer col_rgba = reaper.ImGui_ColorPicker4(ImGui_Context ctx, string label, integer col_rgba, optional integer flagsIn, optional integer ref_colIn)
(Boolean retval, ImGui_Context ctx, String label, Int col_rgbaInOut, Int flagsInOptional, Int ref_colInOptional) = ImGui_ColorPicker4(ctx, label, col_rgbaInOut, flagsInOptional, ref_colInOptional)
bool ImGui_Combo(ImGui_Context* ctx, const char* label, int* current_itemInOut, const char* items, int items_sz, int* popup_max_height_in_itemsInOptional)
bool ImGui_Combo(ImGui_Context ctx, "label", int &current_item, "items", optional int popup_max_height_in_itemsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_Combo", ImGui_Context ctx, "label", int &current_item, "items", optional int popup_max_height_in_itemsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer current_item = reaper.ImGui_Combo(ImGui_Context ctx, string label, integer current_item, string items, optional integer popup_max_height_in_itemsIn)
(Boolean retval, ImGui_Context ctx, String label, Int current_itemInOut, String items, Int items_sz, Int popup_max_height_in_itemsInOptional) = ImGui_Combo(ctx, label, current_itemInOut, items, items_sz, popup_max_height_in_itemsInOptional)

Helper over BeginCombo/EndCombo for convenience purpose. Each item must be
null-terminated (requires REAPER v6.44 or newer for EEL and Lua).

int ImGui_ComboFlags_HeightLarge()
int ImGui_ComboFlags_HeightLarge() (requires REAPER 6.24 or later)
int extension_api("ImGui_ComboFlags_HeightLarge") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ComboFlags_HeightLarge()
Int ImGui_ComboFlags_HeightLarge()

Max ~20 items visible.

int ImGui_ComboFlags_HeightLargest()
int ImGui_ComboFlags_HeightLargest() (requires REAPER 6.24 or later)
int extension_api("ImGui_ComboFlags_HeightLargest") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ComboFlags_HeightLargest()
Int ImGui_ComboFlags_HeightLargest()

As many fitting items as possible.

int ImGui_ComboFlags_HeightRegular()
int ImGui_ComboFlags_HeightRegular() (requires REAPER 6.24 or later)
int extension_api("ImGui_ComboFlags_HeightRegular") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ComboFlags_HeightRegular()
Int ImGui_ComboFlags_HeightRegular()

Max ~8 items visible (default).

int ImGui_ComboFlags_HeightSmall()
int ImGui_ComboFlags_HeightSmall() (requires REAPER 6.24 or later)
int extension_api("ImGui_ComboFlags_HeightSmall") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ComboFlags_HeightSmall()
Int ImGui_ComboFlags_HeightSmall()

Max ~4 items visible. Tip: If you want your combo popup to be a specific size
you can use SetNextWindowSizeConstraints prior to calling BeginCombo.

int ImGui_ComboFlags_NoArrowButton()
int ImGui_ComboFlags_NoArrowButton() (requires REAPER 6.24 or later)
int extension_api("ImGui_ComboFlags_NoArrowButton") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ComboFlags_NoArrowButton()
Int ImGui_ComboFlags_NoArrowButton()

Display on the preview box without the square arrow button.

int ImGui_ComboFlags_NoPreview()
int ImGui_ComboFlags_NoPreview() (requires REAPER 6.24 or later)
int extension_api("ImGui_ComboFlags_NoPreview") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ComboFlags_NoPreview()
Int ImGui_ComboFlags_NoPreview()

Display only a square arrow button.

int ImGui_ComboFlags_None()
int ImGui_ComboFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_ComboFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ComboFlags_None()
Int ImGui_ComboFlags_None()
int ImGui_ComboFlags_PopupAlignLeft()
int ImGui_ComboFlags_PopupAlignLeft() (requires REAPER 6.24 or later)
int extension_api("ImGui_ComboFlags_PopupAlignLeft") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ComboFlags_PopupAlignLeft()
Int ImGui_ComboFlags_PopupAlignLeft()

Align the popup toward the left by default.

int ImGui_Cond_Always()
int ImGui_Cond_Always() (requires REAPER 6.24 or later)
int extension_api("ImGui_Cond_Always") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Cond_Always()
Int ImGui_Cond_Always()

No condition (always set the variable).

int ImGui_Cond_Appearing()
int ImGui_Cond_Appearing() (requires REAPER 6.24 or later)
int extension_api("ImGui_Cond_Appearing") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Cond_Appearing()
Int ImGui_Cond_Appearing()

Set the variable if the object/window is appearing after being
hidden/inactive (or the first time).

int ImGui_Cond_FirstUseEver()
int ImGui_Cond_FirstUseEver() (requires REAPER 6.24 or later)
int extension_api("ImGui_Cond_FirstUseEver") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Cond_FirstUseEver()
Int ImGui_Cond_FirstUseEver()

Set the variable if the object/window has no persistently saved data
(no entry in .ini file).

int ImGui_Cond_Once()
int ImGui_Cond_Once() (requires REAPER 6.24 or later)
int extension_api("ImGui_Cond_Once") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Cond_Once()
Int ImGui_Cond_Once()

Set the variable once per runtime session (only the first call will succeed).

int ImGui_ConfigFlags_DockingEnable()
int ImGui_ConfigFlags_DockingEnable() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigFlags_DockingEnable") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigFlags_DockingEnable()
Int ImGui_ConfigFlags_DockingEnable()

[BETA] Enable docking functionality.

int ImGui_ConfigFlags_NavEnableKeyboard()
int ImGui_ConfigFlags_NavEnableKeyboard() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigFlags_NavEnableKeyboard") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigFlags_NavEnableKeyboard()
Int ImGui_ConfigFlags_NavEnableKeyboard()

Master keyboard navigation enable flag.
Enable full Tabbing + directional arrows + space/enter to activate.

int ImGui_ConfigFlags_NavEnableSetMousePos()
int ImGui_ConfigFlags_NavEnableSetMousePos() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigFlags_NavEnableSetMousePos") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigFlags_NavEnableSetMousePos()
Int ImGui_ConfigFlags_NavEnableSetMousePos()

Instruct navigation to move the mouse cursor.

int ImGui_ConfigFlags_NavNoCaptureKeyboard()
int ImGui_ConfigFlags_NavNoCaptureKeyboard() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigFlags_NavNoCaptureKeyboard") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigFlags_NavNoCaptureKeyboard()
Int ImGui_ConfigFlags_NavNoCaptureKeyboard()

Instruct navigation to not capture global keyboard input when
ConfigFlags_NavEnableKeyboard is set (see SetNextFrameWantCaptureKeyboard).

int ImGui_ConfigFlags_NoMouse()
int ImGui_ConfigFlags_NoMouse() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigFlags_NoMouse") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigFlags_NoMouse()
Int ImGui_ConfigFlags_NoMouse()

Instruct imgui to ignore mouse position/buttons.

int ImGui_ConfigFlags_NoMouseCursorChange()
int ImGui_ConfigFlags_NoMouseCursorChange() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigFlags_NoMouseCursorChange") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigFlags_NoMouseCursorChange()
Int ImGui_ConfigFlags_NoMouseCursorChange()

Instruct backend to not alter mouse cursor shape and visibility.

int ImGui_ConfigFlags_NoSavedSettings()
int ImGui_ConfigFlags_NoSavedSettings() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigFlags_NoSavedSettings") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigFlags_NoSavedSettings()
Int ImGui_ConfigFlags_NoSavedSettings()

Disable state restoration and persistence for the whole context.

int ImGui_ConfigFlags_None()
int ImGui_ConfigFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigFlags_None()
Int ImGui_ConfigFlags_None()
int ImGui_ConfigVar_DebugBeginReturnValueLoop()
int ImGui_ConfigVar_DebugBeginReturnValueLoop() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_DebugBeginReturnValueLoop") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_DebugBeginReturnValueLoop()
Int ImGui_ConfigVar_DebugBeginReturnValueLoop()

Some calls to Begin()/BeginChild() will return false.
Will cycle through window depths then repeat. Suggested use: add
"SetConfigVar(ConfigVar_DebugBeginReturnValueLoop(), GetKeyMods() == Mod_Shift"
in your main loop then occasionally press SHIFT.
Windows should be flickering while running.

int ImGui_ConfigVar_DebugBeginReturnValueOnce()
int ImGui_ConfigVar_DebugBeginReturnValueOnce() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_DebugBeginReturnValueOnce") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_DebugBeginReturnValueOnce()
Int ImGui_ConfigVar_DebugBeginReturnValueOnce()

First-time calls to Begin()/BeginChild() will return false.
**Needs to be set at context startup time** if you don't want to miss windows.

int ImGui_ConfigVar_DockingNoSplit()
int ImGui_ConfigVar_DockingNoSplit() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_DockingNoSplit") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_DockingNoSplit()
Int ImGui_ConfigVar_DockingNoSplit()

Simplified docking mode: disable window splitting, so docking is limited to
merging multiple windows together into tab-bars.

int ImGui_ConfigVar_DockingTransparentPayload()
int ImGui_ConfigVar_DockingTransparentPayload() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_DockingTransparentPayload") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_DockingTransparentPayload()
Int ImGui_ConfigVar_DockingTransparentPayload()

Make window or viewport transparent when docking and only display docking
boxes on the target viewport.

int ImGui_ConfigVar_DockingWithShift()
int ImGui_ConfigVar_DockingWithShift() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_DockingWithShift") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_DockingWithShift()
Int ImGui_ConfigVar_DockingWithShift()

Enable docking with holding Shift key
(reduce visual noise, allows dropping in wider space

int ImGui_ConfigVar_DragClickToInputText()
int ImGui_ConfigVar_DragClickToInputText() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_DragClickToInputText") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_DragClickToInputText()
Int ImGui_ConfigVar_DragClickToInputText()

Enable turning Drag* widgets into text input with a simple mouse
click-release (without moving). Not desirable on devices without a keyboard.

int ImGui_ConfigVar_Flags()
int ImGui_ConfigVar_Flags() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_Flags") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_Flags()
Int ImGui_ConfigVar_Flags()

ConfigFlags_*

int ImGui_ConfigVar_HoverDelayNormal()
int ImGui_ConfigVar_HoverDelayNormal() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_HoverDelayNormal") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_HoverDelayNormal()
Int ImGui_ConfigVar_HoverDelayNormal()

Delay on hovering before IsItemHovered(HoveredFlags_DelayNormal) returns true.

int ImGui_ConfigVar_HoverDelayShort()
int ImGui_ConfigVar_HoverDelayShort() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_HoverDelayShort") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_HoverDelayShort()
Int ImGui_ConfigVar_HoverDelayShort()

Delay on hovering before IsItemHovered(HoveredFlags_DelayShort) returns true.

int ImGui_ConfigVar_InputTextEnterKeepActive()
int ImGui_ConfigVar_InputTextEnterKeepActive() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_InputTextEnterKeepActive") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_InputTextEnterKeepActive()
Int ImGui_ConfigVar_InputTextEnterKeepActive()

Pressing Enter will keep item active and select contents (single-line only).

int ImGui_ConfigVar_InputTrickleEventQueue()
int ImGui_ConfigVar_InputTrickleEventQueue() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_InputTrickleEventQueue") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_InputTrickleEventQueue()
Int ImGui_ConfigVar_InputTrickleEventQueue()

Enable input queue trickling: some types of events submitted during the same
frame (e.g. button down + up) will be spread over multiple frames, improving
interactions with low framerates.

Warning: when this option is disabled mouse clicks and key presses faster
than a frame will be lost.
This affects accessiblity features and some input devices.

int ImGui_ConfigVar_KeyRepeatDelay()
int ImGui_ConfigVar_KeyRepeatDelay() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_KeyRepeatDelay") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_KeyRepeatDelay()
Int ImGui_ConfigVar_KeyRepeatDelay()

When holding a key/button, time before it starts repeating, in seconds
(for buttons in Repeat mode, etc.).

int ImGui_ConfigVar_KeyRepeatRate()
int ImGui_ConfigVar_KeyRepeatRate() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_KeyRepeatRate") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_KeyRepeatRate()
Int ImGui_ConfigVar_KeyRepeatRate()

When holding a key/button, rate at which it repeats, in seconds.

int ImGui_ConfigVar_MacOSXBehaviors()
int ImGui_ConfigVar_MacOSXBehaviors() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_MacOSXBehaviors") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_MacOSXBehaviors()
Int ImGui_ConfigVar_MacOSXBehaviors()

OS X style: Text editing cursor movement using Alt instead of Ctrl, Shortcuts
using Cmd/Super instead of Ctrl, Line/Text Start and End using Cmd+Arrows
instead of Home/End, Double click selects by word instead of selecting whole
text, Multi-selection in lists uses Cmd/Super instead of Ctrl.

int ImGui_ConfigVar_MouseDoubleClickMaxDist()
int ImGui_ConfigVar_MouseDoubleClickMaxDist() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_MouseDoubleClickMaxDist") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_MouseDoubleClickMaxDist()
Int ImGui_ConfigVar_MouseDoubleClickMaxDist()

Distance threshold to stay in to validate a double-click, in pixels.

int ImGui_ConfigVar_MouseDoubleClickTime()
int ImGui_ConfigVar_MouseDoubleClickTime() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_MouseDoubleClickTime") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_MouseDoubleClickTime()
Int ImGui_ConfigVar_MouseDoubleClickTime()

Time for a double-click, in seconds.

int ImGui_ConfigVar_MouseDragThreshold()
int ImGui_ConfigVar_MouseDragThreshold() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_MouseDragThreshold") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_MouseDragThreshold()
Int ImGui_ConfigVar_MouseDragThreshold()

Distance threshold before considering we are dragging.

int ImGui_ConfigVar_ViewportsNoDecoration()
int ImGui_ConfigVar_ViewportsNoDecoration() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_ViewportsNoDecoration") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_ViewportsNoDecoration()
Int ImGui_ConfigVar_ViewportsNoDecoration()

Disable default OS window decoration. Enabling decoration can create
subsequent issues at OS levels (e.g. minimum window size).

int ImGui_ConfigVar_WindowsMoveFromTitleBarOnly()
int ImGui_ConfigVar_WindowsMoveFromTitleBarOnly() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_WindowsMoveFromTitleBarOnly") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_WindowsMoveFromTitleBarOnly()
Int ImGui_ConfigVar_WindowsMoveFromTitleBarOnly()

Enable allowing to move windows only when clicking on their title bar.
Does not apply to windows without a title bar.

int ImGui_ConfigVar_WindowsResizeFromEdges()
int ImGui_ConfigVar_WindowsResizeFromEdges() (requires REAPER 6.24 or later)
int extension_api("ImGui_ConfigVar_WindowsResizeFromEdges") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_ConfigVar_WindowsResizeFromEdges()
Int ImGui_ConfigVar_WindowsResizeFromEdges()

Enable resizing of windows from their edges and from the lower-left corner.

ImGui_Context* ImGui_CreateContext(const char* label, int* config_flagsInOptional)
ImGui_Context ImGui_CreateContext("label", optional int config_flagsIn) (requires REAPER 6.24 or later)
ImGui_Context extension_api("ImGui_CreateContext", "label", optional int config_flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_Context reaper.ImGui_CreateContext(string label, optional integer config_flagsIn)
(ImGui_Context retval, String label, Int config_flagsInOptional) = ImGui_CreateContext(label, config_flagsInOptional)

Create a new ReaImGui context.
The context will remain valid as long as it is used in each defer cycle.

The label is used for the tab text when windows are docked in REAPER
and also as a unique identifier for storing settings.

ImGui_DrawListSplitter* ImGui_CreateDrawListSplitter(ImGui_DrawList* draw_list)
ImGui_DrawListSplitter ImGui_CreateDrawListSplitter(ImGui_DrawList draw_list) (requires REAPER 6.24 or later)
ImGui_DrawListSplitter extension_api("ImGui_CreateDrawListSplitter", ImGui_DrawList draw_list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_DrawListSplitter reaper.ImGui_CreateDrawListSplitter(ImGui_DrawList draw_list)
ImGui_DrawListSplitter ImGui_CreateDrawListSplitter(ImGui_DrawList draw_list)
ImGui_Font* ImGui_CreateFont(const char* family_or_file, int size, int* flagsInOptional)
ImGui_Font ImGui_CreateFont("family_or_file", int size, optional int flagsIn) (requires REAPER 6.24 or later)
ImGui_Font extension_api("ImGui_CreateFont", "family_or_file", int size, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_Font reaper.ImGui_CreateFont(string family_or_file, integer size, optional integer flagsIn)
(ImGui_Font retval, String family_or_file, Int size, Int flagsInOptional) = ImGui_CreateFont(family_or_file, size, flagsInOptional)

Load a font matching a font family name or from a font file.
The font will remain valid while it's attached to a context. See Attach.

The family name can be an installed font or one of the generic fonts:
sans-serif, serif, monospace, cursive, fantasy.

If 'family_or_file' specifies a path to a font file (contains a / or \\):
- The first byte of 'flags' is used as the font index within the file
- The font styles in 'flags' are simulated by the font renderer

ImGui_Function* ImGui_CreateFunctionFromEEL(const char* code)
ImGui_Function ImGui_CreateFunctionFromEEL("code") (requires REAPER 6.24 or later)
ImGui_Function extension_api("ImGui_CreateFunctionFromEEL", "code") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_Function reaper.ImGui_CreateFunctionFromEEL(string code)
ImGui_Function ImGui_CreateFunctionFromEEL(String code)

Compile an EEL program.

Standard EEL [math](https://www.reaper.fm/sdk/js/basiccode.php#js_basicfunc)
and [string](https://www.reaper.fm/sdk/js/strings.php#js_string_funcs)
functions are available in addition to callback-specific functions
(see InputTextCallback_*).

ImGui_Image* ImGui_CreateImage(const char* file, int* flagsInOptional)
ImGui_Image ImGui_CreateImage("file", optional int flagsIn) (requires REAPER 6.24 or later)
ImGui_Image extension_api("ImGui_CreateImage", "file", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_Image reaper.ImGui_CreateImage(string file, optional integer flagsIn)
(ImGui_Image retval, String file, Int flagsInOptional) = ImGui_CreateImage(file, flagsInOptional)

The returned object is valid as long as it is used in each defer cycle
unless attached to a context (see Attach).

('flags' currently unused and reserved for future expansion)

ImGui_Image* ImGui_CreateImageFromMem(const char* data, int data_sz)
ImGui_Image ImGui_CreateImageFromMem("data") (requires REAPER 6.24 or later)
ImGui_Image extension_api("ImGui_CreateImageFromMem", "data") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_Image reaper.ImGui_CreateImageFromMem(string data)
ImGui_Image ImGui_CreateImageFromMem(String data, Int data_sz)

Requires REAPER v6.44 or newer for EEL and Lua. Load from a file using
CreateImage or explicitely specify data_sz if supporting older versions.

ImGui_ImageSet* ImGui_CreateImageSet()
ImGui_ImageSet ImGui_CreateImageSet() (requires REAPER 6.24 or later)
ImGui_ImageSet extension_api("ImGui_CreateImageSet") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_ImageSet = reaper.ImGui_CreateImageSet()
ImGui_ImageSet ImGui_CreateImageSet()
ImGui_ListClipper* ImGui_CreateListClipper(ImGui_Context* ctx)
ImGui_ListClipper ImGui_CreateListClipper(ImGui_Context ctx) (requires REAPER 6.24 or later)
ImGui_ListClipper extension_api("ImGui_CreateListClipper", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_ListClipper reaper.ImGui_CreateListClipper(ImGui_Context ctx)
ImGui_ListClipper ImGui_CreateListClipper(ImGui_Context ctx)

The returned clipper object is only valid for the given context and is valid
as long as it is used in each defer cycle unless attached (see Attach).

ImGui_TextFilter* ImGui_CreateTextFilter(const char* default_filterInOptional)
ImGui_TextFilter ImGui_CreateTextFilter(optional "default_filterIn") (requires REAPER 6.24 or later)
ImGui_TextFilter extension_api("ImGui_CreateTextFilter", optional "default_filterIn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_TextFilter reaper.ImGui_CreateTextFilter(optional string default_filterIn)
ImGui_TextFilter ImGui_CreateTextFilter(String default_filterInOptional)

Valid while used every frame unless attached to a context (see Attach).

void ImGui_DebugTextEncoding(ImGui_Context* ctx, const char* text)
ImGui_DebugTextEncoding(ImGui_Context ctx, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_DebugTextEncoding", ImGui_Context ctx, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DebugTextEncoding(ImGui_Context ctx, string text)
ImGui_DebugTextEncoding(ImGui_Context ctx, String text)

Helper tool to diagnose between text encoding issues and font loading issues.
Pass your UTF-8 string and verify that there are correct.

void ImGui_DestroyContext(ImGui_Context* ctx)
ImGui_DestroyContext(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_DestroyContext", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DestroyContext(ImGui_Context ctx)
ImGui_DestroyContext(ImGui_Context ctx)

Free the resources used by a context.

Calling this function is usually not required as all ReaImGui objects are
automatically garbage-collected when unused.

void ImGui_Detach(ImGui_Context* ctx, ImGui_Resource* obj)
ImGui_Detach(ImGui_Context ctx, ImGui_Resource obj) (requires REAPER 6.24 or later)
extension_api("ImGui_Detach", ImGui_Context ctx, ImGui_Resource obj) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Detach(ImGui_Context ctx, ImGui_Resource obj)
ImGui_Detach(ImGui_Context ctx, ImGui_Resource obj)

Unlink the object's lifetime. Unattached objects are automatically destroyed
when left unused. You may check whether an object has been destroyed using
ValidatePtr.

int ImGui_Dir_Down()
int ImGui_Dir_Down() (requires REAPER 6.24 or later)
int extension_api("ImGui_Dir_Down") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Dir_Down()
Int ImGui_Dir_Down()
int ImGui_Dir_Left()
int ImGui_Dir_Left() (requires REAPER 6.24 or later)
int extension_api("ImGui_Dir_Left") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Dir_Left()
Int ImGui_Dir_Left()
int ImGui_Dir_None()
int ImGui_Dir_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_Dir_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Dir_None()
Int ImGui_Dir_None()
int ImGui_Dir_Right()
int ImGui_Dir_Right() (requires REAPER 6.24 or later)
int extension_api("ImGui_Dir_Right") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Dir_Right()
Int ImGui_Dir_Right()
int ImGui_Dir_Up()
int ImGui_Dir_Up() (requires REAPER 6.24 or later)
int extension_api("ImGui_Dir_Up") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Dir_Up()
Int ImGui_Dir_Up()
bool ImGui_DragDouble(ImGui_Context* ctx, const char* label, double* vInOut, double* v_speedInOptional, double* v_minInOptional, double* v_maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_DragDouble(ImGui_Context ctx, "label", &v, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragDouble", ImGui_Context ctx, "label", &v, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v = reaper.ImGui_DragDouble(ImGui_Context ctx, string label, number v, optional number v_speedIn, optional number v_minIn, optional number v_maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float vInOut, Float v_speedInOptional, Float v_minInOptional, Float v_maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_DragDouble(ctx, label, vInOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, flagsInOptional)
bool ImGui_DragDouble2(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v_speedInOptional, double* v_minInOptional, double* v_maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_DragDouble2(ImGui_Context ctx, "label", &v1, &v2, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragDouble2", ImGui_Context ctx, "label", &v1, &v2, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v1, number v2 = reaper.ImGui_DragDouble2(ImGui_Context ctx, string label, number v1, number v2, optional number v_speedIn, optional number v_minIn, optional number v_maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v1InOut, Float v2InOut, Float v_speedInOptional, Float v_minInOptional, Float v_maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_DragDouble2(ctx, label, v1InOut, v2InOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, flagsInOptional)
bool ImGui_DragDouble3(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double* v_speedInOptional, double* v_minInOptional, double* v_maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_DragDouble3(ImGui_Context ctx, "label", &v1, &v2, &v3, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragDouble3", ImGui_Context ctx, "label", &v1, &v2, &v3, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v1, number v2, number v3 = reaper.ImGui_DragDouble3(ImGui_Context ctx, string label, number v1, number v2, number v3, optional number v_speedIn, optional number v_minIn, optional number v_maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v1InOut, Float v2InOut, Float v3InOut, Float v_speedInOptional, Float v_minInOptional, Float v_maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_DragDouble3(ctx, label, v1InOut, v2InOut, v3InOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, flagsInOptional)
bool ImGui_DragDouble4(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double* v4InOut, double* v_speedInOptional, double* v_minInOptional, double* v_maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_DragDouble4(ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragDouble4", ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v1, number v2, number v3, number v4 = reaper.ImGui_DragDouble4(ImGui_Context ctx, string label, number v1, number v2, number v3, number v4, optional number v_speedIn, optional number v_minIn, optional number v_maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v1InOut, Float v2InOut, Float v3InOut, Float v4InOut, Float v_speedInOptional, Float v_minInOptional, Float v_maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_DragDouble4(ctx, label, v1InOut, v2InOut, v3InOut, v4InOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, flagsInOptional)
bool ImGui_DragDoubleN(ImGui_Context* ctx, const char* label, reaper_array* values, double* speedInOptional, double* minInOptional, double* maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_DragDoubleN(ImGui_Context ctx, "label", reaper_array values, optional speedIn, optional minIn, optional maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragDoubleN", ImGui_Context ctx, "label", reaper_array values, optional speedIn, optional minIn, optional maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_DragDoubleN(ImGui_Context ctx, string label, reaper_array values, optional number speedIn, optional number minIn, optional number maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, reaper_array values, Float speedInOptional, Float minInOptional, Float maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_DragDoubleN(ctx, label, values, speedInOptional, minInOptional, maxInOptional, formatInOptional, flagsInOptional)
int ImGui_DragDropFlags_AcceptBeforeDelivery()
int ImGui_DragDropFlags_AcceptBeforeDelivery() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_AcceptBeforeDelivery") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_AcceptBeforeDelivery()
Int ImGui_DragDropFlags_AcceptBeforeDelivery()

AcceptDragDropPayload will returns true even before the mouse button is
released. You can then check GetDragDropPayload/is_delivery to test if the
payload needs to be delivered.

int ImGui_DragDropFlags_AcceptNoDrawDefaultRect()
int ImGui_DragDropFlags_AcceptNoDrawDefaultRect() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_AcceptNoDrawDefaultRect") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_AcceptNoDrawDefaultRect()
Int ImGui_DragDropFlags_AcceptNoDrawDefaultRect()

Do not draw the default highlight rectangle when hovering over target.

int ImGui_DragDropFlags_AcceptNoPreviewTooltip()
int ImGui_DragDropFlags_AcceptNoPreviewTooltip() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_AcceptNoPreviewTooltip") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_AcceptNoPreviewTooltip()
Int ImGui_DragDropFlags_AcceptNoPreviewTooltip()

Request hiding the BeginDragDropSource tooltip from the BeginDragDropTarget site.

int ImGui_DragDropFlags_AcceptPeekOnly()
int ImGui_DragDropFlags_AcceptPeekOnly() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_AcceptPeekOnly") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_AcceptPeekOnly()
Int ImGui_DragDropFlags_AcceptPeekOnly()

For peeking ahead and inspecting the payload before delivery.
Equivalent to DragDropFlags_AcceptBeforeDelivery |
DragDropFlags_AcceptNoDrawDefaultRect.

int ImGui_DragDropFlags_None()
int ImGui_DragDropFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_None()
Int ImGui_DragDropFlags_None()
int ImGui_DragDropFlags_SourceAllowNullID()
int ImGui_DragDropFlags_SourceAllowNullID() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_SourceAllowNullID") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_SourceAllowNullID()
Int ImGui_DragDropFlags_SourceAllowNullID()

Allow items such as Text, Image that have no unique identifier to be used as
drag source, by manufacturing a temporary identifier based on their
window-relative position. This is extremely unusual within the dear imgui
ecosystem and so we made it explicit.

int ImGui_DragDropFlags_SourceAutoExpirePayload()
int ImGui_DragDropFlags_SourceAutoExpirePayload() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_SourceAutoExpirePayload") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_SourceAutoExpirePayload()
Int ImGui_DragDropFlags_SourceAutoExpirePayload()

Automatically expire the payload if the source cease to be submitted
(otherwise payloads are persisting while being dragged).

int ImGui_DragDropFlags_SourceExtern()
int ImGui_DragDropFlags_SourceExtern() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_SourceExtern") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_SourceExtern()
Int ImGui_DragDropFlags_SourceExtern()

External source (from outside of dear imgui), won't attempt to read current
item/window info. Will always return true.
Only one Extern source can be active simultaneously.

int ImGui_DragDropFlags_SourceNoDisableHover()
int ImGui_DragDropFlags_SourceNoDisableHover() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_SourceNoDisableHover") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_SourceNoDisableHover()
Int ImGui_DragDropFlags_SourceNoDisableHover()

By default, when dragging we clear data so that IsItemHovered will return
false, to avoid subsequent user code submitting tooltips. This flag disables
this behavior so you can still call IsItemHovered on the source item.

int ImGui_DragDropFlags_SourceNoHoldToOpenOthers()
int ImGui_DragDropFlags_SourceNoHoldToOpenOthers() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_SourceNoHoldToOpenOthers") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_SourceNoHoldToOpenOthers()
Int ImGui_DragDropFlags_SourceNoHoldToOpenOthers()

Disable the behavior that allows to open tree nodes and collapsing header by
holding over them while dragging a source item.

int ImGui_DragDropFlags_SourceNoPreviewTooltip()
int ImGui_DragDropFlags_SourceNoPreviewTooltip() (requires REAPER 6.24 or later)
int extension_api("ImGui_DragDropFlags_SourceNoPreviewTooltip") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DragDropFlags_SourceNoPreviewTooltip()
Int ImGui_DragDropFlags_SourceNoPreviewTooltip()

By default, a successful call to BeginDragDropSource opens a tooltip so you
can display a preview or description of the source contents.
This flag disables this behavior.

bool ImGui_DragFloatRange2(ImGui_Context* ctx, const char* label, double* v_current_minInOut, double* v_current_maxInOut, double* v_speedInOptional, double* v_minInOptional, double* v_maxInOptional, const char* formatInOptional, const char* format_maxInOptional, int* flagsInOptional)
bool ImGui_DragFloatRange2(ImGui_Context ctx, "label", &v_current_min, &v_current_max, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional "format_maxIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragFloatRange2", ImGui_Context ctx, "label", &v_current_min, &v_current_max, optional v_speedIn, optional v_minIn, optional v_maxIn, optional "formatIn", optional "format_maxIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v_current_min, number v_current_max = reaper.ImGui_DragFloatRange2(ImGui_Context ctx, string label, number v_current_min, number v_current_max, optional number v_speedIn, optional number v_minIn, optional number v_maxIn, optional string formatIn, optional string format_maxIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v_current_minInOut, Float v_current_maxInOut, Float v_speedInOptional, Float v_minInOptional, Float v_maxInOptional, String formatInOptional, String format_maxInOptional, Int flagsInOptional) = ImGui_DragFloatRange2(ctx, label, v_current_minInOut, v_current_maxInOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, format_maxInOptional, flagsInOptional)
bool ImGui_DragInt(ImGui_Context* ctx, const char* label, int* vInOut, double* v_speedInOptional, int* v_minInOptional, int* v_maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_DragInt(ImGui_Context ctx, "label", int &v, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragInt", ImGui_Context ctx, "label", int &v, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v = reaper.ImGui_DragInt(ImGui_Context ctx, string label, integer v, optional number v_speedIn, optional integer v_minIn, optional integer v_maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int vInOut, Float v_speedInOptional, Int v_minInOptional, Int v_maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_DragInt(ctx, label, vInOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, flagsInOptional)
bool ImGui_DragInt2(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, double* v_speedInOptional, int* v_minInOptional, int* v_maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_DragInt2(ImGui_Context ctx, "label", int &v1, int &v2, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragInt2", ImGui_Context ctx, "label", int &v1, int &v2, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v1, integer v2 = reaper.ImGui_DragInt2(ImGui_Context ctx, string label, integer v1, integer v2, optional number v_speedIn, optional integer v_minIn, optional integer v_maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v1InOut, Int v2InOut, Float v_speedInOptional, Int v_minInOptional, Int v_maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_DragInt2(ctx, label, v1InOut, v2InOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, flagsInOptional)
bool ImGui_DragInt3(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, double* v_speedInOptional, int* v_minInOptional, int* v_maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_DragInt3(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragInt3", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v1, integer v2, integer v3 = reaper.ImGui_DragInt3(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, optional number v_speedIn, optional integer v_minIn, optional integer v_maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v1InOut, Int v2InOut, Int v3InOut, Float v_speedInOptional, Int v_minInOptional, Int v_maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_DragInt3(ctx, label, v1InOut, v2InOut, v3InOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, flagsInOptional)
bool ImGui_DragInt4(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int* v4InOut, double* v_speedInOptional, int* v_minInOptional, int* v_maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_DragInt4(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragInt4", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v1, integer v2, integer v3, integer v4 = reaper.ImGui_DragInt4(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, integer v4, optional number v_speedIn, optional integer v_minIn, optional integer v_maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v1InOut, Int v2InOut, Int v3InOut, Int v4InOut, Float v_speedInOptional, Int v_minInOptional, Int v_maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_DragInt4(ctx, label, v1InOut, v2InOut, v3InOut, v4InOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, flagsInOptional)
bool ImGui_DragIntRange2(ImGui_Context* ctx, const char* label, int* v_current_minInOut, int* v_current_maxInOut, double* v_speedInOptional, int* v_minInOptional, int* v_maxInOptional, const char* formatInOptional, const char* format_maxInOptional, int* flagsInOptional)
bool ImGui_DragIntRange2(ImGui_Context ctx, "label", int &v_current_min, int &v_current_max, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional "format_maxIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_DragIntRange2", ImGui_Context ctx, "label", int &v_current_min, int &v_current_max, optional v_speedIn, optional int v_minIn, optional int v_maxIn, optional "formatIn", optional "format_maxIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v_current_min, integer v_current_max = reaper.ImGui_DragIntRange2(ImGui_Context ctx, string label, integer v_current_min, integer v_current_max, optional number v_speedIn, optional integer v_minIn, optional integer v_maxIn, optional string formatIn, optional string format_maxIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v_current_minInOut, Int v_current_maxInOut, Float v_speedInOptional, Int v_minInOptional, Int v_maxInOptional, String formatInOptional, String format_maxInOptional, Int flagsInOptional) = ImGui_DragIntRange2(ctx, label, v_current_minInOut, v_current_maxInOut, v_speedInOptional, v_minInOptional, v_maxInOptional, formatInOptional, format_maxInOptional, flagsInOptional)
int ImGui_DrawFlags_Closed()
int ImGui_DrawFlags_Closed() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_Closed") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_Closed()
Int ImGui_DrawFlags_Closed()

DrawList_PathStroke, DrawList_AddPolyline: specify that shape should be
closed (Important: this is always == 1 for legacy reason).

int ImGui_DrawFlags_None()
int ImGui_DrawFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_None()
Int ImGui_DrawFlags_None()
int ImGui_DrawFlags_RoundCornersAll()
int ImGui_DrawFlags_RoundCornersAll() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersAll") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersAll()
Int ImGui_DrawFlags_RoundCornersAll()
int ImGui_DrawFlags_RoundCornersBottom()
int ImGui_DrawFlags_RoundCornersBottom() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersBottom") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersBottom()
Int ImGui_DrawFlags_RoundCornersBottom()
int ImGui_DrawFlags_RoundCornersBottomLeft()
int ImGui_DrawFlags_RoundCornersBottomLeft() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersBottomLeft") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersBottomLeft()
Int ImGui_DrawFlags_RoundCornersBottomLeft()

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: enable rounding
bottom-left corner only (when rounding > 0.0, we default to all corners).

int ImGui_DrawFlags_RoundCornersBottomRight()
int ImGui_DrawFlags_RoundCornersBottomRight() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersBottomRight") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersBottomRight()
Int ImGui_DrawFlags_RoundCornersBottomRight()

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: enable rounding
bottom-right corner only (when rounding > 0.0, we default to all corners).

int ImGui_DrawFlags_RoundCornersLeft()
int ImGui_DrawFlags_RoundCornersLeft() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersLeft") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersLeft()
Int ImGui_DrawFlags_RoundCornersLeft()
int ImGui_DrawFlags_RoundCornersNone()
int ImGui_DrawFlags_RoundCornersNone() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersNone") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersNone()
Int ImGui_DrawFlags_RoundCornersNone()

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: disable rounding
on all corners (when rounding > 0.0). This is NOT zero, NOT an implicit flag!.

int ImGui_DrawFlags_RoundCornersRight()
int ImGui_DrawFlags_RoundCornersRight() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersRight") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersRight()
Int ImGui_DrawFlags_RoundCornersRight()
int ImGui_DrawFlags_RoundCornersTop()
int ImGui_DrawFlags_RoundCornersTop() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersTop") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersTop()
Int ImGui_DrawFlags_RoundCornersTop()
int ImGui_DrawFlags_RoundCornersTopLeft()
int ImGui_DrawFlags_RoundCornersTopLeft() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersTopLeft") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersTopLeft()
Int ImGui_DrawFlags_RoundCornersTopLeft()

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: enable rounding
top-left corner only (when rounding > 0.0, we default to all corners).

int ImGui_DrawFlags_RoundCornersTopRight()
int ImGui_DrawFlags_RoundCornersTopRight() (requires REAPER 6.24 or later)
int extension_api("ImGui_DrawFlags_RoundCornersTopRight") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_DrawFlags_RoundCornersTopRight()
Int ImGui_DrawFlags_RoundCornersTopRight()

DrawList_AddRect, DrawList_AddRectFilled, DrawList_PathRect: enable rounding
top-right corner only (when rounding > 0.0, we default to all corners).

void ImGui_DrawListSplitter_Clear(ImGui_DrawListSplitter* splitter)
ImGui_DrawListSplitter_Clear(ImGui_DrawListSplitter splitter) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawListSplitter_Clear", ImGui_DrawListSplitter splitter) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawListSplitter_Clear(ImGui_DrawListSplitter splitter)
ImGui_DrawListSplitter_Clear(ImGui_DrawListSplitter splitter)
void ImGui_DrawListSplitter_Merge(ImGui_DrawListSplitter* splitter)
ImGui_DrawListSplitter_Merge(ImGui_DrawListSplitter splitter) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawListSplitter_Merge", ImGui_DrawListSplitter splitter) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawListSplitter_Merge(ImGui_DrawListSplitter splitter)
ImGui_DrawListSplitter_Merge(ImGui_DrawListSplitter splitter)
void ImGui_DrawListSplitter_SetCurrentChannel(ImGui_DrawListSplitter* splitter, int channel_idx)
ImGui_DrawListSplitter_SetCurrentChannel(ImGui_DrawListSplitter splitter, int channel_idx) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawListSplitter_SetCurrentChannel", ImGui_DrawListSplitter splitter, int channel_idx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawListSplitter_SetCurrentChannel(ImGui_DrawListSplitter splitter, integer channel_idx)
ImGui_DrawListSplitter_SetCurrentChannel(ImGui_DrawListSplitter splitter, Int channel_idx)
void ImGui_DrawListSplitter_Split(ImGui_DrawListSplitter* splitter, int count)
ImGui_DrawListSplitter_Split(ImGui_DrawListSplitter splitter, int count) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawListSplitter_Split", ImGui_DrawListSplitter splitter, int count) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawListSplitter_Split(ImGui_DrawListSplitter splitter, integer count)
ImGui_DrawListSplitter_Split(ImGui_DrawListSplitter splitter, Int count)
void ImGui_DrawList_AddBezierCubic(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, int col_rgba, double thickness, int* num_segmentsInOptional)
ImGui_DrawList_AddBezierCubic(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba, thickness, optional int num_segmentsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddBezierCubic", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba, thickness, optional int num_segmentsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddBezierCubic(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, integer col_rgba, number thickness, optional integer num_segmentsIn)
(ImGui_DrawList draw_list, Float p1_x, Float p1_y, Float p2_x, Float p2_y, Float p3_x, Float p3_y, Float p4_x, Float p4_y, Int col_rgba, Float thickness, Int num_segmentsInOptional) = ImGui_DrawList_AddBezierCubic(draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, col_rgba, thickness, num_segmentsInOptional)

Cubic Bezier (4 control points)

void ImGui_DrawList_AddBezierQuadratic(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, int col_rgba, double thickness, int* num_segmentsInOptional)
ImGui_DrawList_AddBezierQuadratic(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba, thickness, optional int num_segmentsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddBezierQuadratic", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba, thickness, optional int num_segmentsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddBezierQuadratic(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, integer col_rgba, number thickness, optional integer num_segmentsIn)
(ImGui_DrawList draw_list, Float p1_x, Float p1_y, Float p2_x, Float p2_y, Float p3_x, Float p3_y, Int col_rgba, Float thickness, Int num_segmentsInOptional) = ImGui_DrawList_AddBezierQuadratic(draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, col_rgba, thickness, num_segmentsInOptional)

Quadratic Bezier (3 control points)

void ImGui_DrawList_AddCircle(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int col_rgba, int* num_segmentsInOptional, double* thicknessInOptional)
ImGui_DrawList_AddCircle(ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, optional int num_segmentsIn, optional thicknessIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddCircle", ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, optional int num_segmentsIn, optional thicknessIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddCircle(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer col_rgba, optional integer num_segmentsIn, optional number thicknessIn)
(ImGui_DrawList draw_list, Float center_x, Float center_y, Float radius, Int col_rgba, Int num_segmentsInOptional, Float thicknessInOptional) = ImGui_DrawList_AddCircle(draw_list, center_x, center_y, radius, col_rgba, num_segmentsInOptional, thicknessInOptional)

Use "num_segments == 0" to automatically calculate tessellation (preferred).

void ImGui_DrawList_AddCircleFilled(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int col_rgba, int* num_segmentsInOptional)
ImGui_DrawList_AddCircleFilled(ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, optional int num_segmentsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddCircleFilled", ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, optional int num_segmentsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddCircleFilled(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer col_rgba, optional integer num_segmentsIn)
(ImGui_DrawList draw_list, Float center_x, Float center_y, Float radius, Int col_rgba, Int num_segmentsInOptional) = ImGui_DrawList_AddCircleFilled(draw_list, center_x, center_y, radius, col_rgba, num_segmentsInOptional)

Use "num_segments == 0" to automatically calculate tessellation (preferred).

void ImGui_DrawList_AddConvexPolyFilled(ImGui_DrawList* draw_list, reaper_array* points, int col_rgba)
ImGui_DrawList_AddConvexPolyFilled(ImGui_DrawList draw_list, reaper_array points, int col_rgba) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddConvexPolyFilled", ImGui_DrawList draw_list, reaper_array points, int col_rgba) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddConvexPolyFilled(ImGui_DrawList draw_list, reaper_array points, integer col_rgba)
ImGui_DrawList_AddConvexPolyFilled(ImGui_DrawList draw_list, reaper_array points, Int col_rgba)

Note: Anti-aliased filling requires points to be in clockwise order.

void ImGui_DrawList_AddImage(ImGui_DrawList* draw_list, ImGui_Image* img, double p_min_x, double p_min_y, double p_max_x, double p_max_y, double* uv_min_xInOptional, double* uv_min_yInOptional, double* uv_max_xInOptional, double* uv_max_yInOptional, int* col_rgbaInOptional)
ImGui_DrawList_AddImage(ImGui_DrawList draw_list, ImGui_Image img, p_min_x, p_min_y, p_max_x, p_max_y, optional uv_min_xIn, optional uv_min_yIn, optional uv_max_xIn, optional uv_max_yIn, optional int col_rgbaIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddImage", ImGui_DrawList draw_list, ImGui_Image img, p_min_x, p_min_y, p_max_x, p_max_y, optional uv_min_xIn, optional uv_min_yIn, optional uv_max_xIn, optional uv_max_yIn, optional int col_rgbaIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddImage(ImGui_DrawList draw_list, ImGui_Image img, number p_min_x, number p_min_y, number p_max_x, number p_max_y, optional number uv_min_xIn, optional number uv_min_yIn, optional number uv_max_xIn, optional number uv_max_yIn, optional integer col_rgbaIn)
(ImGui_DrawList draw_list, ImGui_Image img, Float p_min_x, Float p_min_y, Float p_max_x, Float p_max_y, Float uv_min_xInOptional, Float uv_min_yInOptional, Float uv_max_xInOptional, Float uv_max_yInOptional, Int col_rgbaInOptional) = ImGui_DrawList_AddImage(draw_list, img, p_min_x, p_min_y, p_max_x, p_max_y, uv_min_xInOptional, uv_min_yInOptional, uv_max_xInOptional, uv_max_yInOptional, col_rgbaInOptional)
void ImGui_DrawList_AddImageQuad(ImGui_DrawList* draw_list, ImGui_Image* img, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, double* uv1_xInOptional, double* uv1_yInOptional, double* uv2_xInOptional, double* uv2_yInOptional, double* uv3_xInOptional, double* uv3_yInOptional, double* uv4_xInOptional, double* uv4_yInOptional, int* col_rgbaInOptional)
ImGui_DrawList_AddImageQuad(ImGui_DrawList draw_list, ImGui_Image img, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, optional uv1_xIn, optional uv1_yIn, optional uv2_xIn, optional uv2_yIn, optional uv3_xIn, optional uv3_yIn, optional uv4_xIn, optional uv4_yIn, optional int col_rgbaIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddImageQuad", ImGui_DrawList draw_list, ImGui_Image img, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, optional uv1_xIn, optional uv1_yIn, optional uv2_xIn, optional uv2_yIn, optional uv3_xIn, optional uv3_yIn, optional uv4_xIn, optional uv4_yIn, optional int col_rgbaIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddImageQuad(ImGui_DrawList draw_list, ImGui_Image img, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, optional number uv1_xIn, optional number uv1_yIn, optional number uv2_xIn, optional number uv2_yIn, optional number uv3_xIn, optional number uv3_yIn, optional number uv4_xIn, optional number uv4_yIn, optional integer col_rgbaIn)
(ImGui_DrawList draw_list, ImGui_Image img, Float p1_x, Float p1_y, Float p2_x, Float p2_y, Float p3_x, Float p3_y, Float p4_x, Float p4_y, Float uv1_xInOptional, Float uv1_yInOptional, Float uv2_xInOptional, Float uv2_yInOptional, Float uv3_xInOptional, Float uv3_yInOptional, Float uv4_xInOptional, Float uv4_yInOptional, Int col_rgbaInOptional) = ImGui_DrawList_AddImageQuad(draw_list, img, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, uv1_xInOptional, uv1_yInOptional, uv2_xInOptional, uv2_yInOptional, uv3_xInOptional, uv3_yInOptional, uv4_xInOptional, uv4_yInOptional, col_rgbaInOptional)
void ImGui_DrawList_AddImageRounded(ImGui_DrawList* draw_list, ImGui_Image* img, double p_min_x, double p_min_y, double p_max_x, double p_max_y, double uv_min_x, double uv_min_y, double uv_max_x, double uv_max_y, int col_rgba, double rounding, int* flagsInOptional)
ImGui_DrawList_AddImageRounded(ImGui_DrawList draw_list, ImGui_Image img, p_min_x, p_min_y, p_max_x, p_max_y, uv_min_x, uv_min_y, uv_max_x, uv_max_y, int col_rgba, rounding, optional int flagsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddImageRounded", ImGui_DrawList draw_list, ImGui_Image img, p_min_x, p_min_y, p_max_x, p_max_y, uv_min_x, uv_min_y, uv_max_x, uv_max_y, int col_rgba, rounding, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddImageRounded(ImGui_DrawList draw_list, ImGui_Image img, number p_min_x, number p_min_y, number p_max_x, number p_max_y, number uv_min_x, number uv_min_y, number uv_max_x, number uv_max_y, integer col_rgba, number rounding, optional integer flagsIn)
(ImGui_DrawList draw_list, ImGui_Image img, Float p_min_x, Float p_min_y, Float p_max_x, Float p_max_y, Float uv_min_x, Float uv_min_y, Float uv_max_x, Float uv_max_y, Int col_rgba, Float rounding, Int flagsInOptional) = ImGui_DrawList_AddImageRounded(draw_list, img, p_min_x, p_min_y, p_max_x, p_max_y, uv_min_x, uv_min_y, uv_max_x, uv_max_y, col_rgba, rounding, flagsInOptional)
void ImGui_DrawList_AddLine(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, int col_rgba, double* thicknessInOptional)
ImGui_DrawList_AddLine(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, int col_rgba, optional thicknessIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddLine", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, int col_rgba, optional thicknessIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddLine(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, integer col_rgba, optional number thicknessIn)
(ImGui_DrawList draw_list, Float p1_x, Float p1_y, Float p2_x, Float p2_y, Int col_rgba, Float thicknessInOptional) = ImGui_DrawList_AddLine(draw_list, p1_x, p1_y, p2_x, p2_y, col_rgba, thicknessInOptional)
void ImGui_DrawList_AddNgon(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int col_rgba, int num_segments, double* thicknessInOptional)
ImGui_DrawList_AddNgon(ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments, optional thicknessIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddNgon", ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments, optional thicknessIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddNgon(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer col_rgba, integer num_segments, optional number thicknessIn)
(ImGui_DrawList draw_list, Float center_x, Float center_y, Float radius, Int col_rgba, Int num_segments, Float thicknessInOptional) = ImGui_DrawList_AddNgon(draw_list, center_x, center_y, radius, col_rgba, num_segments, thicknessInOptional)
void ImGui_DrawList_AddNgonFilled(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int col_rgba, int num_segments)
ImGui_DrawList_AddNgonFilled(ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddNgonFilled", ImGui_DrawList draw_list, center_x, center_y, radius, int col_rgba, int num_segments) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddNgonFilled(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer col_rgba, integer num_segments)
ImGui_DrawList_AddNgonFilled(ImGui_DrawList draw_list, Float center_x, Float center_y, Float radius, Int col_rgba, Int num_segments)
void ImGui_DrawList_AddPolyline(ImGui_DrawList* draw_list, reaper_array* points, int col_rgba, int flags, double thickness)
ImGui_DrawList_AddPolyline(ImGui_DrawList draw_list, reaper_array points, int col_rgba, int flags, thickness) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddPolyline", ImGui_DrawList draw_list, reaper_array points, int col_rgba, int flags, thickness) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddPolyline(ImGui_DrawList draw_list, reaper_array points, integer col_rgba, integer flags, number thickness)
ImGui_DrawList_AddPolyline(ImGui_DrawList draw_list, reaper_array points, Int col_rgba, Int flags, Float thickness)

Points is a list of x,y coordinates.

void ImGui_DrawList_AddQuad(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, int col_rgba, double* thicknessInOptional)
ImGui_DrawList_AddQuad(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba, optional thicknessIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddQuad", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba, optional thicknessIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddQuad(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, integer col_rgba, optional number thicknessIn)
(ImGui_DrawList draw_list, Float p1_x, Float p1_y, Float p2_x, Float p2_y, Float p3_x, Float p3_y, Float p4_x, Float p4_y, Int col_rgba, Float thicknessInOptional) = ImGui_DrawList_AddQuad(draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, col_rgba, thicknessInOptional)
void ImGui_DrawList_AddQuadFilled(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, int col_rgba)
ImGui_DrawList_AddQuadFilled(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddQuadFilled", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, int col_rgba) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddQuadFilled(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, integer col_rgba)
ImGui_DrawList_AddQuadFilled(ImGui_DrawList draw_list, Float p1_x, Float p1_y, Float p2_x, Float p2_y, Float p3_x, Float p3_y, Float p4_x, Float p4_y, Int col_rgba)
void ImGui_DrawList_AddRect(ImGui_DrawList* draw_list, double p_min_x, double p_min_y, double p_max_x, double p_max_y, int col_rgba, double* roundingInOptional, int* flagsInOptional, double* thicknessInOptional)
ImGui_DrawList_AddRect(ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_rgba, optional roundingIn, optional int flagsIn, optional thicknessIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddRect", ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_rgba, optional roundingIn, optional int flagsIn, optional thicknessIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddRect(ImGui_DrawList draw_list, number p_min_x, number p_min_y, number p_max_x, number p_max_y, integer col_rgba, optional number roundingIn, optional integer flagsIn, optional number thicknessIn)
(ImGui_DrawList draw_list, Float p_min_x, Float p_min_y, Float p_max_x, Float p_max_y, Int col_rgba, Float roundingInOptional, Int flagsInOptional, Float thicknessInOptional) = ImGui_DrawList_AddRect(draw_list, p_min_x, p_min_y, p_max_x, p_max_y, col_rgba, roundingInOptional, flagsInOptional, thicknessInOptional)
void ImGui_DrawList_AddRectFilled(ImGui_DrawList* draw_list, double p_min_x, double p_min_y, double p_max_x, double p_max_y, int col_rgba, double* roundingInOptional, int* flagsInOptional)
ImGui_DrawList_AddRectFilled(ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_rgba, optional roundingIn, optional int flagsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddRectFilled", ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_rgba, optional roundingIn, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddRectFilled(ImGui_DrawList draw_list, number p_min_x, number p_min_y, number p_max_x, number p_max_y, integer col_rgba, optional number roundingIn, optional integer flagsIn)
(ImGui_DrawList draw_list, Float p_min_x, Float p_min_y, Float p_max_x, Float p_max_y, Int col_rgba, Float roundingInOptional, Int flagsInOptional) = ImGui_DrawList_AddRectFilled(draw_list, p_min_x, p_min_y, p_max_x, p_max_y, col_rgba, roundingInOptional, flagsInOptional)
void ImGui_DrawList_AddRectFilledMultiColor(ImGui_DrawList* draw_list, double p_min_x, double p_min_y, double p_max_x, double p_max_y, int col_upr_left, int col_upr_right, int col_bot_right, int col_bot_left)
ImGui_DrawList_AddRectFilledMultiColor(ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_upr_left, int col_upr_right, int col_bot_right, int col_bot_left) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddRectFilledMultiColor", ImGui_DrawList draw_list, p_min_x, p_min_y, p_max_x, p_max_y, int col_upr_left, int col_upr_right, int col_bot_right, int col_bot_left) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddRectFilledMultiColor(ImGui_DrawList draw_list, number p_min_x, number p_min_y, number p_max_x, number p_max_y, integer col_upr_left, integer col_upr_right, integer col_bot_right, integer col_bot_left)
ImGui_DrawList_AddRectFilledMultiColor(ImGui_DrawList draw_list, Float p_min_x, Float p_min_y, Float p_max_x, Float p_max_y, Int col_upr_left, Int col_upr_right, Int col_bot_right, Int col_bot_left)
void ImGui_DrawList_AddText(ImGui_DrawList* draw_list, double x, double y, int col_rgba, const char* text)
ImGui_DrawList_AddText(ImGui_DrawList draw_list, x, y, int col_rgba, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddText", ImGui_DrawList draw_list, x, y, int col_rgba, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddText(ImGui_DrawList draw_list, number x, number y, integer col_rgba, string text)
ImGui_DrawList_AddText(ImGui_DrawList draw_list, Float x, Float y, Int col_rgba, String text)
void ImGui_DrawList_AddTextEx(ImGui_DrawList* draw_list, ImGui_Font* font, double font_size, double pos_x, double pos_y, int col_rgba, const char* text, double* wrap_widthInOptional, double* cpu_fine_clip_rect_xInOptional, double* cpu_fine_clip_rect_yInOptional, double* cpu_fine_clip_rect_wInOptional, double* cpu_fine_clip_rect_hInOptional)
ImGui_DrawList_AddTextEx(ImGui_DrawList draw_list, ImGui_Font font, font_size, pos_x, pos_y, int col_rgba, "text", optional wrap_widthIn, optional cpu_fine_clip_rect_xIn, optional cpu_fine_clip_rect_yIn, optional cpu_fine_clip_rect_wIn, optional cpu_fine_clip_rect_hIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddTextEx", ImGui_DrawList draw_list, ImGui_Font font, font_size, pos_x, pos_y, int col_rgba, "text", optional wrap_widthIn, optional cpu_fine_clip_rect_xIn, optional cpu_fine_clip_rect_yIn, optional cpu_fine_clip_rect_wIn, optional cpu_fine_clip_rect_hIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddTextEx(ImGui_DrawList draw_list, ImGui_Font font, number font_size, number pos_x, number pos_y, integer col_rgba, string text, optional number wrap_widthIn, optional number cpu_fine_clip_rect_xIn, optional number cpu_fine_clip_rect_yIn, optional number cpu_fine_clip_rect_wIn, optional number cpu_fine_clip_rect_hIn)
(ImGui_DrawList draw_list, ImGui_Font font, Float font_size, Float pos_x, Float pos_y, Int col_rgba, String text, Float wrap_widthInOptional, Float cpu_fine_clip_rect_xInOptional, Float cpu_fine_clip_rect_yInOptional, Float cpu_fine_clip_rect_wInOptional, Float cpu_fine_clip_rect_hInOptional) = ImGui_DrawList_AddTextEx(draw_list, font, font_size, pos_x, pos_y, col_rgba, text, wrap_widthInOptional, cpu_fine_clip_rect_xInOptional, cpu_fine_clip_rect_yInOptional, cpu_fine_clip_rect_wInOptional, cpu_fine_clip_rect_hInOptional)

The last pushed font is used if font is nil.
The size of the last pushed font is used if font_size is 0.
cpu_fine_clip_rect_* only takes effect if all four are non-nil.

void ImGui_DrawList_AddTriangle(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, int col_rgba, double* thicknessInOptional)
ImGui_DrawList_AddTriangle(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba, optional thicknessIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddTriangle", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba, optional thicknessIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddTriangle(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, integer col_rgba, optional number thicknessIn)
(ImGui_DrawList draw_list, Float p1_x, Float p1_y, Float p2_x, Float p2_y, Float p3_x, Float p3_y, Int col_rgba, Float thicknessInOptional) = ImGui_DrawList_AddTriangle(draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, col_rgba, thicknessInOptional)
void ImGui_DrawList_AddTriangleFilled(ImGui_DrawList* draw_list, double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, int col_rgba)
ImGui_DrawList_AddTriangleFilled(ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_AddTriangleFilled", ImGui_DrawList draw_list, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, int col_rgba) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_AddTriangleFilled(ImGui_DrawList draw_list, number p1_x, number p1_y, number p2_x, number p2_y, number p3_x, number p3_y, integer col_rgba)
ImGui_DrawList_AddTriangleFilled(ImGui_DrawList draw_list, Float p1_x, Float p1_y, Float p2_x, Float p2_y, Float p3_x, Float p3_y, Int col_rgba)
void ImGui_DrawList_PathArcTo(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, double a_min, double a_max, int* num_segmentsInOptional)
ImGui_DrawList_PathArcTo(ImGui_DrawList draw_list, center_x, center_y, radius, a_min, a_max, optional int num_segmentsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PathArcTo", ImGui_DrawList draw_list, center_x, center_y, radius, a_min, a_max, optional int num_segmentsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PathArcTo(ImGui_DrawList draw_list, number center_x, number center_y, number radius, number a_min, number a_max, optional integer num_segmentsIn)
(ImGui_DrawList draw_list, Float center_x, Float center_y, Float radius, Float a_min, Float a_max, Int num_segmentsInOptional) = ImGui_DrawList_PathArcTo(draw_list, center_x, center_y, radius, a_min, a_max, num_segmentsInOptional)
void ImGui_DrawList_PathArcToFast(ImGui_DrawList* draw_list, double center_x, double center_y, double radius, int a_min_of_12, int a_max_of_12)
ImGui_DrawList_PathArcToFast(ImGui_DrawList draw_list, center_x, center_y, radius, int a_min_of_12, int a_max_of_12) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PathArcToFast", ImGui_DrawList draw_list, center_x, center_y, radius, int a_min_of_12, int a_max_of_12) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PathArcToFast(ImGui_DrawList draw_list, number center_x, number center_y, number radius, integer a_min_of_12, integer a_max_of_12)
ImGui_DrawList_PathArcToFast(ImGui_DrawList draw_list, Float center_x, Float center_y, Float radius, Int a_min_of_12, Int a_max_of_12)

Use precomputed angles for a 12 steps circle.

void ImGui_DrawList_PathBezierCubicCurveTo(ImGui_DrawList* draw_list, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y, int* num_segmentsInOptional)
ImGui_DrawList_PathBezierCubicCurveTo(ImGui_DrawList draw_list, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, optional int num_segmentsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PathBezierCubicCurveTo", ImGui_DrawList draw_list, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, optional int num_segmentsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PathBezierCubicCurveTo(ImGui_DrawList draw_list, number p2_x, number p2_y, number p3_x, number p3_y, number p4_x, number p4_y, optional integer num_segmentsIn)
(ImGui_DrawList draw_list, Float p2_x, Float p2_y, Float p3_x, Float p3_y, Float p4_x, Float p4_y, Int num_segmentsInOptional) = ImGui_DrawList_PathBezierCubicCurveTo(draw_list, p2_x, p2_y, p3_x, p3_y, p4_x, p4_y, num_segmentsInOptional)

Cubic Bezier (4 control points)

void ImGui_DrawList_PathBezierQuadraticCurveTo(ImGui_DrawList* draw_list, double p2_x, double p2_y, double p3_x, double p3_y, int* num_segmentsInOptional)
ImGui_DrawList_PathBezierQuadraticCurveTo(ImGui_DrawList draw_list, p2_x, p2_y, p3_x, p3_y, optional int num_segmentsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PathBezierQuadraticCurveTo", ImGui_DrawList draw_list, p2_x, p2_y, p3_x, p3_y, optional int num_segmentsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PathBezierQuadraticCurveTo(ImGui_DrawList draw_list, number p2_x, number p2_y, number p3_x, number p3_y, optional integer num_segmentsIn)
(ImGui_DrawList draw_list, Float p2_x, Float p2_y, Float p3_x, Float p3_y, Int num_segmentsInOptional) = ImGui_DrawList_PathBezierQuadraticCurveTo(draw_list, p2_x, p2_y, p3_x, p3_y, num_segmentsInOptional)

Quadratic Bezier (3 control points)

void ImGui_DrawList_PathClear(ImGui_DrawList* draw_list)
ImGui_DrawList_PathClear(ImGui_DrawList draw_list) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PathClear", ImGui_DrawList draw_list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PathClear(ImGui_DrawList draw_list)
ImGui_DrawList_PathClear(ImGui_DrawList draw_list)
void ImGui_DrawList_PathFillConvex(ImGui_DrawList* draw_list, int col_rgba)
ImGui_DrawList_PathFillConvex(ImGui_DrawList draw_list, int col_rgba) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PathFillConvex", ImGui_DrawList draw_list, int col_rgba) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PathFillConvex(ImGui_DrawList draw_list, integer col_rgba)
ImGui_DrawList_PathFillConvex(ImGui_DrawList draw_list, Int col_rgba)

Note: Anti-aliased filling requires points to be in clockwise order.

void ImGui_DrawList_PathLineTo(ImGui_DrawList* draw_list, double pos_x, double pos_y)
ImGui_DrawList_PathLineTo(ImGui_DrawList draw_list, pos_x, pos_y) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PathLineTo", ImGui_DrawList draw_list, pos_x, pos_y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PathLineTo(ImGui_DrawList draw_list, number pos_x, number pos_y)
ImGui_DrawList_PathLineTo(ImGui_DrawList draw_list, Float pos_x, Float pos_y)
void ImGui_DrawList_PathRect(ImGui_DrawList* draw_list, double rect_min_x, double rect_min_y, double rect_max_x, double rect_max_y, double* roundingInOptional, int* flagsInOptional)
ImGui_DrawList_PathRect(ImGui_DrawList draw_list, rect_min_x, rect_min_y, rect_max_x, rect_max_y, optional roundingIn, optional int flagsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PathRect", ImGui_DrawList draw_list, rect_min_x, rect_min_y, rect_max_x, rect_max_y, optional roundingIn, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PathRect(ImGui_DrawList draw_list, number rect_min_x, number rect_min_y, number rect_max_x, number rect_max_y, optional number roundingIn, optional integer flagsIn)
(ImGui_DrawList draw_list, Float rect_min_x, Float rect_min_y, Float rect_max_x, Float rect_max_y, Float roundingInOptional, Int flagsInOptional) = ImGui_DrawList_PathRect(draw_list, rect_min_x, rect_min_y, rect_max_x, rect_max_y, roundingInOptional, flagsInOptional)
void ImGui_DrawList_PathStroke(ImGui_DrawList* draw_list, int col_rgba, int* flagsInOptional, double* thicknessInOptional)
ImGui_DrawList_PathStroke(ImGui_DrawList draw_list, int col_rgba, optional int flagsIn, optional thicknessIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PathStroke", ImGui_DrawList draw_list, int col_rgba, optional int flagsIn, optional thicknessIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PathStroke(ImGui_DrawList draw_list, integer col_rgba, optional integer flagsIn, optional number thicknessIn)
(ImGui_DrawList draw_list, Int col_rgba, Int flagsInOptional, Float thicknessInOptional) = ImGui_DrawList_PathStroke(draw_list, col_rgba, flagsInOptional, thicknessInOptional)
void ImGui_DrawList_PopClipRect(ImGui_DrawList* draw_list)
ImGui_DrawList_PopClipRect(ImGui_DrawList draw_list) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PopClipRect", ImGui_DrawList draw_list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PopClipRect(ImGui_DrawList draw_list)
ImGui_DrawList_PopClipRect(ImGui_DrawList draw_list)

See DrawList_PushClipRect

void ImGui_DrawList_PushClipRect(ImGui_DrawList* draw_list, double clip_rect_min_x, double clip_rect_min_y, double clip_rect_max_x, double clip_rect_max_y, bool* intersect_with_current_clip_rectInOptional)
ImGui_DrawList_PushClipRect(ImGui_DrawList draw_list, clip_rect_min_x, clip_rect_min_y, clip_rect_max_x, clip_rect_max_y, optional bool intersect_with_current_clip_rectIn) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PushClipRect", ImGui_DrawList draw_list, clip_rect_min_x, clip_rect_min_y, clip_rect_max_x, clip_rect_max_y, optional bool intersect_with_current_clip_rectIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PushClipRect(ImGui_DrawList draw_list, number clip_rect_min_x, number clip_rect_min_y, number clip_rect_max_x, number clip_rect_max_y, optional boolean intersect_with_current_clip_rectIn)
(ImGui_DrawList draw_list, Float clip_rect_min_x, Float clip_rect_min_y, Float clip_rect_max_x, Float clip_rect_max_y, Boolean intersect_with_current_clip_rectInOptional) = ImGui_DrawList_PushClipRect(draw_list, clip_rect_min_x, clip_rect_min_y, clip_rect_max_x, clip_rect_max_y, intersect_with_current_clip_rectInOptional)

Render-level scissoring. Prefer using higher-level PushClipRect to affect
logic (hit-testing and widget culling).

void ImGui_DrawList_PushClipRectFullScreen(ImGui_DrawList* draw_list)
ImGui_DrawList_PushClipRectFullScreen(ImGui_DrawList draw_list) (requires REAPER 6.24 or later)
extension_api("ImGui_DrawList_PushClipRectFullScreen", ImGui_DrawList draw_list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_DrawList_PushClipRectFullScreen(ImGui_DrawList draw_list)
ImGui_DrawList_PushClipRectFullScreen(ImGui_DrawList draw_list)
void ImGui_Dummy(ImGui_Context* ctx, double size_w, double size_h)
ImGui_Dummy(ImGui_Context ctx, size_w, size_h) (requires REAPER 6.24 or later)
extension_api("ImGui_Dummy", ImGui_Context ctx, size_w, size_h) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Dummy(ImGui_Context ctx, number size_w, number size_h)
ImGui_Dummy(ImGui_Context ctx, Float size_w, Float size_h)

Add a dummy item of given size. unlike InvisibleButton, Dummy() won't take the
mouse click or be navigable into.

void ImGui_End(ImGui_Context* ctx)
ImGui_End(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_End", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_End(ImGui_Context ctx)
ImGui_End(ImGui_Context ctx)

Pop window from the stack. See Begin.

void ImGui_EndChild(ImGui_Context* ctx)
ImGui_EndChild(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndChild", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndChild(ImGui_Context ctx)
ImGui_EndChild(ImGui_Context ctx)

See BeginChild.

void ImGui_EndChildFrame(ImGui_Context* ctx)
ImGui_EndChildFrame(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndChildFrame", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndChildFrame(ImGui_Context ctx)
ImGui_EndChildFrame(ImGui_Context ctx)

See BeginChildFrame.

void ImGui_EndCombo(ImGui_Context* ctx)
ImGui_EndCombo(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndCombo", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndCombo(ImGui_Context ctx)
ImGui_EndCombo(ImGui_Context ctx)

Only call EndCombo() if BeginCombo returns true!

void ImGui_EndDisabled(ImGui_Context* ctx)
ImGui_EndDisabled(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndDisabled", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndDisabled(ImGui_Context ctx)
ImGui_EndDisabled(ImGui_Context ctx)

See BeginDisabled.

void ImGui_EndDragDropSource(ImGui_Context* ctx)
ImGui_EndDragDropSource(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndDragDropSource", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndDragDropSource(ImGui_Context ctx)
ImGui_EndDragDropSource(ImGui_Context ctx)

Only call EndDragDropSource() if BeginDragDropSource returns true!

void ImGui_EndDragDropTarget(ImGui_Context* ctx)
ImGui_EndDragDropTarget(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndDragDropTarget", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndDragDropTarget(ImGui_Context ctx)
ImGui_EndDragDropTarget(ImGui_Context ctx)

Only call EndDragDropTarget() if BeginDragDropTarget returns true!

void ImGui_EndGroup(ImGui_Context* ctx)
ImGui_EndGroup(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndGroup", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndGroup(ImGui_Context ctx)
ImGui_EndGroup(ImGui_Context ctx)

Unlock horizontal starting position + capture the whole group bounding box
into one "item" (so you can use IsItemHovered or layout primitives such as
SameLine on whole group, etc.).

See BeginGroup.

void ImGui_EndListBox(ImGui_Context* ctx)
ImGui_EndListBox(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndListBox", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndListBox(ImGui_Context ctx)
ImGui_EndListBox(ImGui_Context ctx)

Only call EndListBox() if BeginListBox returned true!

void ImGui_EndMenu(ImGui_Context* ctx)
ImGui_EndMenu(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndMenu", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndMenu(ImGui_Context ctx)
ImGui_EndMenu(ImGui_Context ctx)

Only call EndMenu() if BeginMenu returns true!

void ImGui_EndMenuBar(ImGui_Context* ctx)
ImGui_EndMenuBar(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndMenuBar", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndMenuBar(ImGui_Context ctx)
ImGui_EndMenuBar(ImGui_Context ctx)

Only call EndMenuBar if BeginMenuBar returns true!

void ImGui_EndPopup(ImGui_Context* ctx)
ImGui_EndPopup(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndPopup", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndPopup(ImGui_Context ctx)
ImGui_EndPopup(ImGui_Context ctx)

Only call EndPopup() if BeginPopup*() returns true!

void ImGui_EndTabBar(ImGui_Context* ctx)
ImGui_EndTabBar(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndTabBar", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndTabBar(ImGui_Context ctx)
ImGui_EndTabBar(ImGui_Context ctx)

Only call EndTabBar() if BeginTabBar() returns true!

void ImGui_EndTabItem(ImGui_Context* ctx)
ImGui_EndTabItem(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndTabItem", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndTabItem(ImGui_Context ctx)
ImGui_EndTabItem(ImGui_Context ctx)

Only call EndTabItem() if BeginTabItem() returns true!

void ImGui_EndTable(ImGui_Context* ctx)
ImGui_EndTable(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndTable", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndTable(ImGui_Context ctx)
ImGui_EndTable(ImGui_Context ctx)

Only call EndTable() if BeginTable() returns true!

void ImGui_EndTooltip(ImGui_Context* ctx)
ImGui_EndTooltip(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_EndTooltip", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_EndTooltip(ImGui_Context ctx)
ImGui_EndTooltip(ImGui_Context ctx)

Only call EndTooltip() if BeginTooltip() returns true.

int ImGui_FocusedFlags_AnyWindow()
int ImGui_FocusedFlags_AnyWindow() (requires REAPER 6.24 or later)
int extension_api("ImGui_FocusedFlags_AnyWindow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FocusedFlags_AnyWindow()
Int ImGui_FocusedFlags_AnyWindow()

Return true if any window is focused.

int ImGui_FocusedFlags_ChildWindows()
int ImGui_FocusedFlags_ChildWindows() (requires REAPER 6.24 or later)
int extension_api("ImGui_FocusedFlags_ChildWindows") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FocusedFlags_ChildWindows()
Int ImGui_FocusedFlags_ChildWindows()

Return true if any children of the window is focused.

int ImGui_FocusedFlags_DockHierarchy()
int ImGui_FocusedFlags_DockHierarchy() (requires REAPER 6.24 or later)
int extension_api("ImGui_FocusedFlags_DockHierarchy") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FocusedFlags_DockHierarchy()
Int ImGui_FocusedFlags_DockHierarchy()

Consider docking hierarchy (treat dockspace host as parent of docked window)
(when used with _ChildWindows or _RootWindow).

int ImGui_FocusedFlags_NoPopupHierarchy()
int ImGui_FocusedFlags_NoPopupHierarchy() (requires REAPER 6.24 or later)
int extension_api("ImGui_FocusedFlags_NoPopupHierarchy") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FocusedFlags_NoPopupHierarchy()
Int ImGui_FocusedFlags_NoPopupHierarchy()

Do not consider popup hierarchy (do not treat popup emitter as parent of
popup) (when used with _ChildWindows or _RootWindow).

int ImGui_FocusedFlags_None()
int ImGui_FocusedFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_FocusedFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FocusedFlags_None()
Int ImGui_FocusedFlags_None()
int ImGui_FocusedFlags_RootAndChildWindows()
int ImGui_FocusedFlags_RootAndChildWindows() (requires REAPER 6.24 or later)
int extension_api("ImGui_FocusedFlags_RootAndChildWindows") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FocusedFlags_RootAndChildWindows()
Int ImGui_FocusedFlags_RootAndChildWindows()

FocusedFlags_RootWindow | FocusedFlags_ChildWindows

int ImGui_FocusedFlags_RootWindow()
int ImGui_FocusedFlags_RootWindow() (requires REAPER 6.24 or later)
int extension_api("ImGui_FocusedFlags_RootWindow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FocusedFlags_RootWindow()
Int ImGui_FocusedFlags_RootWindow()

Test from root window (top most parent of the current hierarchy).

int ImGui_FontFlags_Bold()
int ImGui_FontFlags_Bold() (requires REAPER 6.24 or later)
int extension_api("ImGui_FontFlags_Bold") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FontFlags_Bold()
Int ImGui_FontFlags_Bold()
int ImGui_FontFlags_Italic()
int ImGui_FontFlags_Italic() (requires REAPER 6.24 or later)
int extension_api("ImGui_FontFlags_Italic") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FontFlags_Italic()
Int ImGui_FontFlags_Italic()
int ImGui_FontFlags_None()
int ImGui_FontFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_FontFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_FontFlags_None()
Int ImGui_FontFlags_None()
void ImGui_Function_Execute(ImGui_Function* func)
ImGui_Function_Execute(ImGui_Function func) (requires REAPER 6.24 or later)
extension_api("ImGui_Function_Execute", ImGui_Function func) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Function_Execute(ImGui_Function func)
ImGui_Function_Execute(ImGui_Function func)
double ImGui_Function_GetValue(ImGui_Function* func, const char* name)
double ImGui_Function_GetValue(ImGui_Function func, "name") (requires REAPER 6.24 or later)
double extension_api("ImGui_Function_GetValue", ImGui_Function func, "name") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_Function_GetValue(ImGui_Function func, string name)
Float ImGui_Function_GetValue(ImGui_Function func, String name)
void ImGui_Function_GetValue_Array(ImGui_Function* func, const char* name, reaper_array* values)
ImGui_Function_GetValue_Array(ImGui_Function func, "name", reaper_array values) (requires REAPER 6.24 or later)
extension_api("ImGui_Function_GetValue_Array", ImGui_Function func, "name", reaper_array values) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Function_GetValue_Array(ImGui_Function func, string name, reaper_array values)
ImGui_Function_GetValue_Array(ImGui_Function func, String name, reaper_array values)

Copy the values in the function's memory starting at the address stored
in the given variable into the array.

void ImGui_Function_GetValue_String(ImGui_Function* func, const char* name, char* valueOutNeedBig, int valueOutNeedBig_sz)
ImGui_Function_GetValue_String(ImGui_Function func, "name", #value) (requires REAPER 6.24 or later)
extension_api("ImGui_Function_GetValue_String", ImGui_Function func, "name", #value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string value = reaper.ImGui_Function_GetValue_String(ImGui_Function func, string name)
(ImGui_Function func, String name, String valueOutNeedBig, Int valueOutNeedBig_sz) = ImGui_Function_GetValue_String(func, name, valueOutNeedBig, valueOutNeedBig_sz)

Read from a string slot or a named string (when name starts with a `#`).

void ImGui_Function_SetValue(ImGui_Function* func, const char* name, double value)
ImGui_Function_SetValue(ImGui_Function func, "name", value) (requires REAPER 6.24 or later)
extension_api("ImGui_Function_SetValue", ImGui_Function func, "name", value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Function_SetValue(ImGui_Function func, string name, number value)
ImGui_Function_SetValue(ImGui_Function func, String name, Float value)
void ImGui_Function_SetValue_Array(ImGui_Function* func, const char* name, reaper_array* values)
ImGui_Function_SetValue_Array(ImGui_Function func, "name", reaper_array values) (requires REAPER 6.24 or later)
extension_api("ImGui_Function_SetValue_Array", ImGui_Function func, "name", reaper_array values) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Function_SetValue_Array(ImGui_Function func, string name, reaper_array values)
ImGui_Function_SetValue_Array(ImGui_Function func, String name, reaper_array values)

Copy the values in the array to the function's memory at the address stored
in the given variable.

void ImGui_Function_SetValue_String(ImGui_Function* func, const char* name, const char* value, int value_sz)
ImGui_Function_SetValue_String(ImGui_Function func, "name", "value") (requires REAPER 6.24 or later)
extension_api("ImGui_Function_SetValue_String", ImGui_Function func, "name", "value") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Function_SetValue_String(ImGui_Function func, string name, string value)
ImGui_Function_SetValue_String(ImGui_Function func, String name, String value, Int value_sz)

Write to a string slot or a named string (when name starts with a `#`).

ImGui_DrawList* ImGui_GetBackgroundDrawList(ImGui_Context* ctx)
ImGui_DrawList ImGui_GetBackgroundDrawList(ImGui_Context ctx) (requires REAPER 6.24 or later)
ImGui_DrawList extension_api("ImGui_GetBackgroundDrawList", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_DrawList reaper.ImGui_GetBackgroundDrawList(ImGui_Context ctx)
ImGui_DrawList ImGui_GetBackgroundDrawList(ImGui_Context ctx)

This draw list will be the first rendering one. Useful to quickly draw
shapes/text behind dear imgui contents.

const char* ImGui_GetClipboardText(ImGui_Context* ctx)
bool ImGui_GetClipboardText(#retval, ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_GetClipboardText", #retval, ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string reaper.ImGui_GetClipboardText(ImGui_Context ctx)
String ImGui_GetClipboardText(ImGui_Context ctx)
int ImGui_GetColor(ImGui_Context* ctx, int idx, double* alpha_mulInOptional)
int ImGui_GetColor(ImGui_Context ctx, int idx, optional alpha_mulIn) (requires REAPER 6.24 or later)
int extension_api("ImGui_GetColor", ImGui_Context ctx, int idx, optional alpha_mulIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_GetColor(ImGui_Context ctx, integer idx, optional number alpha_mulIn)
(Int retval, ImGui_Context ctx, Int idx, Float alpha_mulInOptional) = ImGui_GetColor(ctx, idx, alpha_mulInOptional)

Retrieve given style color with style alpha applied and optional extra alpha
multiplier, packed as a 32-bit value (RGBA). See Col_* for available style colors.

int ImGui_GetColorEx(ImGui_Context* ctx, int col_rgba)
int ImGui_GetColorEx(ImGui_Context ctx, int col_rgba) (requires REAPER 6.24 or later)
int extension_api("ImGui_GetColorEx", ImGui_Context ctx, int col_rgba) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_GetColorEx(ImGui_Context ctx, integer col_rgba)
Int ImGui_GetColorEx(ImGui_Context ctx, Int col_rgba)

Retrieve given color with style alpha applied, packed as a 32-bit value (RGBA).

double ImGui_GetConfigVar(ImGui_Context* ctx, int var_idx)
double ImGui_GetConfigVar(ImGui_Context ctx, int var_idx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetConfigVar", ImGui_Context ctx, int var_idx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetConfigVar(ImGui_Context ctx, integer var_idx)
Float ImGui_GetConfigVar(ImGui_Context ctx, Int var_idx)
void ImGui_GetContentRegionAvail(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetContentRegionAvail(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetContentRegionAvail", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetContentRegionAvail(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetContentRegionAvail(ctx, xOut, yOut)

== GetContentRegionMax() - GetCursorPos()

void ImGui_GetContentRegionMax(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetContentRegionMax(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetContentRegionMax", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetContentRegionMax(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetContentRegionMax(ctx, xOut, yOut)

Current content boundaries (typically window boundaries including scrolling,
or current column boundaries), in windows coordinates.

void ImGui_GetCursorPos(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetCursorPos(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetCursorPos", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetCursorPos(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetCursorPos(ctx, xOut, yOut)

Cursor position in window

double ImGui_GetCursorPosX(ImGui_Context* ctx)
double ImGui_GetCursorPosX(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetCursorPosX", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetCursorPosX(ImGui_Context ctx)
Float ImGui_GetCursorPosX(ImGui_Context ctx)

Cursor X position in window

double ImGui_GetCursorPosY(ImGui_Context* ctx)
double ImGui_GetCursorPosY(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetCursorPosY", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetCursorPosY(ImGui_Context ctx)
Float ImGui_GetCursorPosY(ImGui_Context ctx)

Cursor Y position in window

void ImGui_GetCursorScreenPos(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetCursorScreenPos(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetCursorScreenPos", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetCursorScreenPos(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetCursorScreenPos(ctx, xOut, yOut)

Cursor position in absolute screen coordinates (useful to work with the DrawList API).

void ImGui_GetCursorStartPos(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetCursorStartPos(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetCursorStartPos", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetCursorStartPos(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetCursorStartPos(ctx, xOut, yOut)

Initial cursor position in window coordinates.

double ImGui_GetDeltaTime(ImGui_Context* ctx)
double ImGui_GetDeltaTime(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetDeltaTime", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetDeltaTime(ImGui_Context ctx)
Float ImGui_GetDeltaTime(ImGui_Context ctx)

Time elapsed since last frame, in seconds.

bool ImGui_GetDragDropPayload(ImGui_Context* ctx, char* typeOut, int typeOut_sz, char* payloadOutNeedBig, int payloadOutNeedBig_sz, bool* is_previewOut, bool* is_deliveryOut)
bool ImGui_GetDragDropPayload(ImGui_Context ctx, #type, #payload, bool &is_preview, bool &is_delivery) (requires REAPER 6.24 or later)
bool extension_api("ImGui_GetDragDropPayload", ImGui_Context ctx, #type, #payload, bool &is_preview, bool &is_delivery) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string type, string payload, boolean is_preview, boolean is_delivery = reaper.ImGui_GetDragDropPayload(ImGui_Context ctx)
(Boolean retval, ImGui_Context ctx, String typeOut, Int typeOut_sz, String payloadOutNeedBig, Int payloadOutNeedBig_sz, Boolean is_previewOut, Boolean is_deliveryOut) = ImGui_GetDragDropPayload(ctx, typeOut, typeOut_sz, payloadOutNeedBig, payloadOutNeedBig_sz, is_previewOut, is_deliveryOut)

Peek directly into the current payload from anywhere.

bool ImGui_GetDragDropPayloadFile(ImGui_Context* ctx, int index, char* filenameOut, int filenameOut_sz)
bool ImGui_GetDragDropPayloadFile(ImGui_Context ctx, int index, #filename) (requires REAPER 6.24 or later)
bool extension_api("ImGui_GetDragDropPayloadFile", ImGui_Context ctx, int index, #filename) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string filename = reaper.ImGui_GetDragDropPayloadFile(ImGui_Context ctx, integer index)
(Boolean retval, ImGui_Context ctx, Int index, String filenameOut, Int filenameOut_sz) = ImGui_GetDragDropPayloadFile(ctx, index, filenameOut, filenameOut_sz)

Get a filename from the list of dropped files.
Returns false if index is out of bounds.

ImGui_Font* ImGui_GetFont(ImGui_Context* ctx)
ImGui_Font ImGui_GetFont(ImGui_Context ctx) (requires REAPER 6.24 or later)
ImGui_Font extension_api("ImGui_GetFont", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_Font reaper.ImGui_GetFont(ImGui_Context ctx)
ImGui_Font ImGui_GetFont(ImGui_Context ctx)

Get the current font

double ImGui_GetFontSize(ImGui_Context* ctx)
double ImGui_GetFontSize(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetFontSize", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetFontSize(ImGui_Context ctx)
Float ImGui_GetFontSize(ImGui_Context ctx)

Get current font size (= height in pixels) of current font with current scale
applied.

ImGui_DrawList* ImGui_GetForegroundDrawList(ImGui_Context* ctx)
ImGui_DrawList ImGui_GetForegroundDrawList(ImGui_Context ctx) (requires REAPER 6.24 or later)
ImGui_DrawList extension_api("ImGui_GetForegroundDrawList", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_DrawList reaper.ImGui_GetForegroundDrawList(ImGui_Context ctx)
ImGui_DrawList ImGui_GetForegroundDrawList(ImGui_Context ctx)

This draw list will be the last rendered one. Useful to quickly draw
shapes/text over dear imgui contents.

int ImGui_GetFrameCount(ImGui_Context* ctx)
int ImGui_GetFrameCount(ImGui_Context ctx) (requires REAPER 6.24 or later)
int extension_api("ImGui_GetFrameCount", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_GetFrameCount(ImGui_Context ctx)
Int ImGui_GetFrameCount(ImGui_Context ctx)

Get global imgui frame count. incremented by 1 every frame.

double ImGui_GetFrameHeight(ImGui_Context* ctx)
double ImGui_GetFrameHeight(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetFrameHeight", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetFrameHeight(ImGui_Context ctx)
Float ImGui_GetFrameHeight(ImGui_Context ctx)

GetFontSize + StyleVar_FramePadding.y * 2

double ImGui_GetFrameHeightWithSpacing(ImGui_Context* ctx)
double ImGui_GetFrameHeightWithSpacing(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetFrameHeightWithSpacing", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetFrameHeightWithSpacing(ImGui_Context ctx)
Float ImGui_GetFrameHeightWithSpacing(ImGui_Context ctx)

GetFontSize + StyleVar_FramePadding.y * 2 + StyleVar_ItemSpacing.y
(distance in pixels between 2 consecutive lines of framed widgets).

double ImGui_GetFramerate(ImGui_Context* ctx)
double ImGui_GetFramerate(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetFramerate", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetFramerate(ImGui_Context ctx)
Float ImGui_GetFramerate(ImGui_Context ctx)

Estimate of application framerate (rolling average over 60 frames, based on
GetDeltaTime), in frame per second. Solely for convenience.

bool ImGui_GetInputQueueCharacter(ImGui_Context* ctx, int idx, int* unicode_charOut)
bool ImGui_GetInputQueueCharacter(ImGui_Context ctx, int idx, int &unicode_char) (requires REAPER 6.24 or later)
bool extension_api("ImGui_GetInputQueueCharacter", ImGui_Context ctx, int idx, int &unicode_char) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer unicode_char = reaper.ImGui_GetInputQueueCharacter(ImGui_Context ctx, integer idx)
(Boolean retval, ImGui_Context ctx, Int idx, Int unicode_charOut) = ImGui_GetInputQueueCharacter(ctx, idx, unicode_charOut)

Read from ImGui's character input queue.
Call with increasing idx until false is returned.

void ImGui_GetItemRectMax(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetItemRectMax(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetItemRectMax", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetItemRectMax(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetItemRectMax(ctx, xOut, yOut)

Get lower-right bounding rectangle of the last item (screen space)

void ImGui_GetItemRectMin(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetItemRectMin(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetItemRectMin", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetItemRectMin(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetItemRectMin(ctx, xOut, yOut)

Get upper-left bounding rectangle of the last item (screen space)

void ImGui_GetItemRectSize(ImGui_Context* ctx, double* wOut, double* hOut)
ImGui_GetItemRectSize(ImGui_Context ctx, &w, &h) (requires REAPER 6.24 or later)
extension_api("ImGui_GetItemRectSize", ImGui_Context ctx, &w, &h) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number w, number h = reaper.ImGui_GetItemRectSize(ImGui_Context ctx)
(ImGui_Context ctx, Float wOut, Float hOut) = ImGui_GetItemRectSize(ctx, wOut, hOut)

Get size of last item

double ImGui_GetKeyDownDuration(ImGui_Context* ctx, int key)
double ImGui_GetKeyDownDuration(ImGui_Context ctx, int key) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetKeyDownDuration", ImGui_Context ctx, int key) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetKeyDownDuration(ImGui_Context ctx, integer key)
Float ImGui_GetKeyDownDuration(ImGui_Context ctx, Int key)

Duration the keyboard key has been down (0.0 == just pressed)

int ImGui_GetKeyMods(ImGui_Context* ctx)
int ImGui_GetKeyMods(ImGui_Context ctx) (requires REAPER 6.24 or later)
int extension_api("ImGui_GetKeyMods", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_GetKeyMods(ImGui_Context ctx)
Int ImGui_GetKeyMods(ImGui_Context ctx)

Flags for the Ctrl/Shift/Alt/Super keys. Uses Mod_* values.

int ImGui_GetKeyPressedAmount(ImGui_Context* ctx, int key, double repeat_delay, double rate)
int ImGui_GetKeyPressedAmount(ImGui_Context ctx, int key, repeat_delay, rate) (requires REAPER 6.24 or later)
int extension_api("ImGui_GetKeyPressedAmount", ImGui_Context ctx, int key, repeat_delay, rate) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_GetKeyPressedAmount(ImGui_Context ctx, integer key, number repeat_delay, number rate)
Int ImGui_GetKeyPressedAmount(ImGui_Context ctx, Int key, Float repeat_delay, Float rate)

Uses provided repeat rate/delay. Return a count, most often 0 or 1 but might
be >1 if ConfigVar_RepeatRate is small enough that GetDeltaTime > RepeatRate.

ImGui_Viewport* ImGui_GetMainViewport(ImGui_Context* ctx)
ImGui_Viewport ImGui_GetMainViewport(ImGui_Context ctx) (requires REAPER 6.24 or later)
ImGui_Viewport extension_api("ImGui_GetMainViewport", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_Viewport reaper.ImGui_GetMainViewport(ImGui_Context ctx)
ImGui_Viewport ImGui_GetMainViewport(ImGui_Context ctx)

Currently represents REAPER's main window (arrange view).
WARNING: This may change or be removed in the future.

int ImGui_GetMouseClickedCount(ImGui_Context* ctx, int button)
int ImGui_GetMouseClickedCount(ImGui_Context ctx, int button) (requires REAPER 6.24 or later)
int extension_api("ImGui_GetMouseClickedCount", ImGui_Context ctx, int button) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_GetMouseClickedCount(ImGui_Context ctx, integer button)
Int ImGui_GetMouseClickedCount(ImGui_Context ctx, Int button)

Return the number of successive mouse-clicks at the time where a click happen (otherwise 0).

void ImGui_GetMouseClickedPos(ImGui_Context* ctx, int button, double* xOut, double* yOut)
ImGui_GetMouseClickedPos(ImGui_Context ctx, int button, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetMouseClickedPos", ImGui_Context ctx, int button, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetMouseClickedPos(ImGui_Context ctx, integer button)
(ImGui_Context ctx, Int button, Float xOut, Float yOut) = ImGui_GetMouseClickedPos(ctx, button, xOut, yOut)
int ImGui_GetMouseCursor(ImGui_Context* ctx)
int ImGui_GetMouseCursor(ImGui_Context ctx) (requires REAPER 6.24 or later)
int extension_api("ImGui_GetMouseCursor", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_GetMouseCursor(ImGui_Context ctx)
Int ImGui_GetMouseCursor(ImGui_Context ctx)

Get desired mouse cursor shape, reset every frame. This is updated during the frame.

void ImGui_GetMouseDelta(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetMouseDelta(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetMouseDelta", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetMouseDelta(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetMouseDelta(ctx, xOut, yOut)

Mouse delta. Note that this is zero if either current or previous position
are invalid (-FLT_MAX,-FLT_MAX), so a disappearing/reappearing mouse won't have
a huge delta.

double ImGui_GetMouseDownDuration(ImGui_Context* ctx, int button)
double ImGui_GetMouseDownDuration(ImGui_Context ctx, int button) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetMouseDownDuration", ImGui_Context ctx, int button) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetMouseDownDuration(ImGui_Context ctx, integer button)
Float ImGui_GetMouseDownDuration(ImGui_Context ctx, Int button)

Duration the mouse button has been down (0.0 == just clicked)

void ImGui_GetMouseDragDelta(ImGui_Context* ctx, double* xOut, double* yOut, int* buttonInOptional, double* lock_thresholdInOptional)
ImGui_GetMouseDragDelta(ImGui_Context ctx, &x, &y, optional int buttonIn, optional lock_thresholdIn) (requires REAPER 6.24 or later)
extension_api("ImGui_GetMouseDragDelta", ImGui_Context ctx, &x, &y, optional int buttonIn, optional lock_thresholdIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetMouseDragDelta(ImGui_Context ctx, number x, number y, optional integer buttonIn, optional number lock_thresholdIn)
(ImGui_Context ctx, Float xOut, Float yOut, Int buttonInOptional, Float lock_thresholdInOptional) = ImGui_GetMouseDragDelta(ctx, xOut, yOut, buttonInOptional, lock_thresholdInOptional)

Return the delta from the initial clicking position while the mouse button is
pressed or was just released. This is locked and return 0.0 until the mouse
moves past a distance threshold at least once (if lock_threshold < -1.0, uses
ConfigVar_MouseDragThreshold).

void ImGui_GetMousePos(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetMousePos(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetMousePos", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetMousePos(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetMousePos(ctx, xOut, yOut)
void ImGui_GetMousePosOnOpeningCurrentPopup(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetMousePosOnOpeningCurrentPopup(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetMousePosOnOpeningCurrentPopup", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetMousePosOnOpeningCurrentPopup(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetMousePosOnOpeningCurrentPopup(ctx, xOut, yOut)

Retrieve mouse position at the time of opening popup we have BeginPopup()
into (helper to avoid user backing that value themselves).

void ImGui_GetMouseWheel(ImGui_Context* ctx, double* verticalOut, double* horizontalOut)
ImGui_GetMouseWheel(ImGui_Context ctx, &vertical, &horizontal) (requires REAPER 6.24 or later)
extension_api("ImGui_GetMouseWheel", ImGui_Context ctx, &vertical, &horizontal) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number vertical, number horizontal = reaper.ImGui_GetMouseWheel(ImGui_Context ctx)
(ImGui_Context ctx, Float verticalOut, Float horizontalOut) = ImGui_GetMouseWheel(ctx, verticalOut, horizontalOut)

Vertical: 1 unit scrolls about 5 lines text. >0 scrolls Up, <0 scrolls Down.
Hold SHIFT to turn vertical scroll into horizontal scroll

Horizontal: >0 scrolls Left, <0 scrolls Right.
Most users don't have a mouse with a horizontal wheel.

double ImGui_GetScrollMaxX(ImGui_Context* ctx)
double ImGui_GetScrollMaxX(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetScrollMaxX", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetScrollMaxX(ImGui_Context ctx)
Float ImGui_GetScrollMaxX(ImGui_Context ctx)

Get maximum scrolling amount ~~ ContentSize.x - WindowSize.x - DecorationsSize.x

double ImGui_GetScrollMaxY(ImGui_Context* ctx)
double ImGui_GetScrollMaxY(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetScrollMaxY", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetScrollMaxY(ImGui_Context ctx)
Float ImGui_GetScrollMaxY(ImGui_Context ctx)

Get maximum scrolling amount ~~ ContentSize.y - WindowSize.y - DecorationsSize.y

double ImGui_GetScrollX(ImGui_Context* ctx)
double ImGui_GetScrollX(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetScrollX", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetScrollX(ImGui_Context ctx)
Float ImGui_GetScrollX(ImGui_Context ctx)

Get scrolling amount [0 .. GetScrollMaxX()]

double ImGui_GetScrollY(ImGui_Context* ctx)
double ImGui_GetScrollY(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetScrollY", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetScrollY(ImGui_Context ctx)
Float ImGui_GetScrollY(ImGui_Context ctx)

Get scrolling amount [0 .. GetScrollMaxY()]

int ImGui_GetStyleColor(ImGui_Context* ctx, int idx)
int ImGui_GetStyleColor(ImGui_Context ctx, int idx) (requires REAPER 6.24 or later)
int extension_api("ImGui_GetStyleColor", ImGui_Context ctx, int idx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_GetStyleColor(ImGui_Context ctx, integer idx)
Int ImGui_GetStyleColor(ImGui_Context ctx, Int idx)

Retrieve style color as stored in ImGuiStyle structure.
Use to feed back into PushStyleColor, Otherwise use GetColor to get style color
with style alpha baked in. See Col_* for available style colors.

void ImGui_GetStyleVar(ImGui_Context* ctx, int var_idx, double* val1Out, double* val2Out)
ImGui_GetStyleVar(ImGui_Context ctx, int var_idx, &val1, &val2) (requires REAPER 6.24 or later)
extension_api("ImGui_GetStyleVar", ImGui_Context ctx, int var_idx, &val1, &val2) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number val1, number val2 = reaper.ImGui_GetStyleVar(ImGui_Context ctx, integer var_idx)
(ImGui_Context ctx, Int var_idx, Float val1Out, Float val2Out) = ImGui_GetStyleVar(ctx, var_idx, val1Out, val2Out)
double ImGui_GetTextLineHeight(ImGui_Context* ctx)
double ImGui_GetTextLineHeight(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetTextLineHeight", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetTextLineHeight(ImGui_Context ctx)
Float ImGui_GetTextLineHeight(ImGui_Context ctx)

Same as GetFontSize

double ImGui_GetTextLineHeightWithSpacing(ImGui_Context* ctx)
double ImGui_GetTextLineHeightWithSpacing(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetTextLineHeightWithSpacing", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetTextLineHeightWithSpacing(ImGui_Context ctx)
Float ImGui_GetTextLineHeightWithSpacing(ImGui_Context ctx)

GetFontSize + StyleVar_ItemSpacing.y
(distance in pixels between 2 consecutive lines of text).

double ImGui_GetTime(ImGui_Context* ctx)
double ImGui_GetTime(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetTime", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetTime(ImGui_Context ctx)
Float ImGui_GetTime(ImGui_Context ctx)

Get global imgui time. Incremented every frame.

double ImGui_GetTreeNodeToLabelSpacing(ImGui_Context* ctx)
double ImGui_GetTreeNodeToLabelSpacing(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetTreeNodeToLabelSpacing", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetTreeNodeToLabelSpacing(ImGui_Context ctx)
Float ImGui_GetTreeNodeToLabelSpacing(ImGui_Context ctx)

Horizontal distance preceding label when using TreeNode*() or Bullet()
== (GetFontSize + StyleVar_FramePadding.x*2) for a regular unframed TreeNode.

void ImGui_GetVersion(char* imgui_versionOut, int imgui_versionOut_sz, int* imgui_version_numOut, char* reaimgui_versionOut, int reaimgui_versionOut_sz)
ImGui_GetVersion(#imgui_version, int &imgui_version_num, #reaimgui_version) (requires REAPER 6.24 or later)
extension_api("ImGui_GetVersion", #imgui_version, int &imgui_version_num, #reaimgui_version) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string imgui_version, integer imgui_version_num, string reaimgui_version = reaper.ImGui_GetVersion()
(String imgui_versionOut, Int imgui_versionOut_sz, Int imgui_version_numOut, String reaimgui_versionOut, Int reaimgui_versionOut_sz) = ImGui_GetVersion(imgui_versionOut, imgui_versionOut_sz, imgui_version_numOut, reaimgui_versionOut, reaimgui_versionOut_sz)
void ImGui_GetWindowContentRegionMax(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetWindowContentRegionMax(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetWindowContentRegionMax", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetWindowContentRegionMax(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetWindowContentRegionMax(ctx, xOut, yOut)

Content boundaries max (roughly (0,0)+Size-Scroll) where Size can be
overridden with SetNextWindowContentSize, in window coordinates.

void ImGui_GetWindowContentRegionMin(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetWindowContentRegionMin(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetWindowContentRegionMin", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetWindowContentRegionMin(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetWindowContentRegionMin(ctx, xOut, yOut)

Content boundaries min (roughly (0,0)-Scroll), in window coordinates.

int ImGui_GetWindowDockID(ImGui_Context* ctx)
int ImGui_GetWindowDockID(ImGui_Context ctx) (requires REAPER 6.24 or later)
int extension_api("ImGui_GetWindowDockID", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_GetWindowDockID(ImGui_Context ctx)
Int ImGui_GetWindowDockID(ImGui_Context ctx)
double ImGui_GetWindowDpiScale(ImGui_Context* ctx)
double ImGui_GetWindowDpiScale(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetWindowDpiScale", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetWindowDpiScale(ImGui_Context ctx)
Float ImGui_GetWindowDpiScale(ImGui_Context ctx)

Get DPI scale currently associated to the current window's viewport
(1.0 = 96 DPI).

ImGui_DrawList* ImGui_GetWindowDrawList(ImGui_Context* ctx)
ImGui_DrawList ImGui_GetWindowDrawList(ImGui_Context ctx) (requires REAPER 6.24 or later)
ImGui_DrawList extension_api("ImGui_GetWindowDrawList", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_DrawList reaper.ImGui_GetWindowDrawList(ImGui_Context ctx)
ImGui_DrawList ImGui_GetWindowDrawList(ImGui_Context ctx)

The draw list associated to the current window, to append your own drawing primitives

double ImGui_GetWindowHeight(ImGui_Context* ctx)
double ImGui_GetWindowHeight(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetWindowHeight", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetWindowHeight(ImGui_Context ctx)
Float ImGui_GetWindowHeight(ImGui_Context ctx)

Get current window height (shortcut for (select(2, GetWindowSize())).

void ImGui_GetWindowPos(ImGui_Context* ctx, double* xOut, double* yOut)
ImGui_GetWindowPos(ImGui_Context ctx, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_GetWindowPos", ImGui_Context ctx, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_GetWindowPos(ImGui_Context ctx)
(ImGui_Context ctx, Float xOut, Float yOut) = ImGui_GetWindowPos(ctx, xOut, yOut)

Get current window position in screen space (useful if you want to do your own
drawing via the DrawList API).

void ImGui_GetWindowSize(ImGui_Context* ctx, double* wOut, double* hOut)
ImGui_GetWindowSize(ImGui_Context ctx, &w, &h) (requires REAPER 6.24 or later)
extension_api("ImGui_GetWindowSize", ImGui_Context ctx, &w, &h) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number w, number h = reaper.ImGui_GetWindowSize(ImGui_Context ctx)
(ImGui_Context ctx, Float wOut, Float hOut) = ImGui_GetWindowSize(ctx, wOut, hOut)

Get current window size

ImGui_Viewport* ImGui_GetWindowViewport(ImGui_Context* ctx)
ImGui_Viewport ImGui_GetWindowViewport(ImGui_Context ctx) (requires REAPER 6.24 or later)
ImGui_Viewport extension_api("ImGui_GetWindowViewport", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
ImGui_Viewport reaper.ImGui_GetWindowViewport(ImGui_Context ctx)
ImGui_Viewport ImGui_GetWindowViewport(ImGui_Context ctx)

Get viewport currently associated to the current window.

double ImGui_GetWindowWidth(ImGui_Context* ctx)
double ImGui_GetWindowWidth(ImGui_Context ctx) (requires REAPER 6.24 or later)
double extension_api("ImGui_GetWindowWidth", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.ImGui_GetWindowWidth(ImGui_Context ctx)
Float ImGui_GetWindowWidth(ImGui_Context ctx)

Get current window width (shortcut for (select(1, GetWindowSize())).

int ImGui_HoveredFlags_AllowWhenBlockedByActiveItem()
int ImGui_HoveredFlags_AllowWhenBlockedByActiveItem() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_AllowWhenBlockedByActiveItem") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_AllowWhenBlockedByActiveItem()
Int ImGui_HoveredFlags_AllowWhenBlockedByActiveItem()

Return true even if an active item is blocking access to this item/window.
Useful for Drag and Drop patterns.

int ImGui_HoveredFlags_AllowWhenBlockedByPopup()
int ImGui_HoveredFlags_AllowWhenBlockedByPopup() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_AllowWhenBlockedByPopup") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_AllowWhenBlockedByPopup()
Int ImGui_HoveredFlags_AllowWhenBlockedByPopup()

Return true even if a popup window is normally blocking access to this item/window.

int ImGui_HoveredFlags_AllowWhenDisabled()
int ImGui_HoveredFlags_AllowWhenDisabled() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_AllowWhenDisabled") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_AllowWhenDisabled()
Int ImGui_HoveredFlags_AllowWhenDisabled()

IsItemHovered only: Return true even if the item is disabled.

int ImGui_HoveredFlags_AllowWhenOverlapped()
int ImGui_HoveredFlags_AllowWhenOverlapped() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_AllowWhenOverlapped") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_AllowWhenOverlapped()
Int ImGui_HoveredFlags_AllowWhenOverlapped()

IsItemHovered only: Return true even if the position is obstructed or
overlapped by another window.

int ImGui_HoveredFlags_AnyWindow()
int ImGui_HoveredFlags_AnyWindow() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_AnyWindow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_AnyWindow()
Int ImGui_HoveredFlags_AnyWindow()

IsWindowHovered only: Return true if any window is hovered.

int ImGui_HoveredFlags_ChildWindows()
int ImGui_HoveredFlags_ChildWindows() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_ChildWindows") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_ChildWindows()
Int ImGui_HoveredFlags_ChildWindows()

IsWindowHovered only: Return true if any children of the window is hovered.

int ImGui_HoveredFlags_DelayNormal()
int ImGui_HoveredFlags_DelayNormal() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_DelayNormal") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_DelayNormal()
Int ImGui_HoveredFlags_DelayNormal()

Return true after ConfigVar_HoverDelayNormal elapsed (~0.30 sec)

int ImGui_HoveredFlags_DelayShort()
int ImGui_HoveredFlags_DelayShort() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_DelayShort") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_DelayShort()
Int ImGui_HoveredFlags_DelayShort()

Return true after ConfigVar_HoverDelayShort elapsed (~0.10 sec)

int ImGui_HoveredFlags_DockHierarchy()
int ImGui_HoveredFlags_DockHierarchy() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_DockHierarchy") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_DockHierarchy()
Int ImGui_HoveredFlags_DockHierarchy()

IsWindowHovered only: Consider docking hierarchy (treat dockspace host as
parent of docked window) (when used with _ChildWindows or _RootWindow).

int ImGui_HoveredFlags_NoNavOverride()
int ImGui_HoveredFlags_NoNavOverride() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_NoNavOverride") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_NoNavOverride()
Int ImGui_HoveredFlags_NoNavOverride()

Disable using gamepad/keyboard navigation state when active, always query mouse.

int ImGui_HoveredFlags_NoPopupHierarchy()
int ImGui_HoveredFlags_NoPopupHierarchy() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_NoPopupHierarchy") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_NoPopupHierarchy()
Int ImGui_HoveredFlags_NoPopupHierarchy()

IsWindowHovered only: Do not consider popup hierarchy (do not treat popup
emitter as parent of popup) (when used with _ChildWindows or _RootWindow).

int ImGui_HoveredFlags_NoSharedDelay()
int ImGui_HoveredFlags_NoSharedDelay() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_NoSharedDelay") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_NoSharedDelay()
Int ImGui_HoveredFlags_NoSharedDelay()

Disable shared delay system where moving from one item to the next keeps
the previous timer for a short time (standard for tooltips with long delays

int ImGui_HoveredFlags_None()
int ImGui_HoveredFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_None()
Int ImGui_HoveredFlags_None()

Return true if directly over the item/window, not obstructed by another
window, not obstructed by an active popup or modal blocking inputs under them.

int ImGui_HoveredFlags_RectOnly()
int ImGui_HoveredFlags_RectOnly() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_RectOnly") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_RectOnly()
Int ImGui_HoveredFlags_RectOnly()

HoveredFlags_AllowWhenBlockedByPopup |
HoveredFlags_AllowWhenBlockedByActiveItem | HoveredFlags_AllowWhenOverlapped

int ImGui_HoveredFlags_RootAndChildWindows()
int ImGui_HoveredFlags_RootAndChildWindows() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_RootAndChildWindows") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_RootAndChildWindows()
Int ImGui_HoveredFlags_RootAndChildWindows()

HoveredFlags_RootWindow | HoveredFlags_ChildWindows

int ImGui_HoveredFlags_RootWindow()
int ImGui_HoveredFlags_RootWindow() (requires REAPER 6.24 or later)
int extension_api("ImGui_HoveredFlags_RootWindow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_HoveredFlags_RootWindow()
Int ImGui_HoveredFlags_RootWindow()

IsWindowHovered only: Test from root window (top most parent of the current hierarchy).

void ImGui_Image(ImGui_Context* ctx, ImGui_Image* img, double size_w, double size_h, double* uv0_xInOptional, double* uv0_yInOptional, double* uv1_xInOptional, double* uv1_yInOptional, int* tint_col_rgbaInOptional, int* border_col_rgbaInOptional)
ImGui_Image(ImGui_Context ctx, ImGui_Image img, size_w, size_h, optional uv0_xIn, optional uv0_yIn, optional uv1_xIn, optional uv1_yIn, optional int tint_col_rgbaIn, optional int border_col_rgbaIn) (requires REAPER 6.24 or later)
extension_api("ImGui_Image", ImGui_Context ctx, ImGui_Image img, size_w, size_h, optional uv0_xIn, optional uv0_yIn, optional uv1_xIn, optional uv1_yIn, optional int tint_col_rgbaIn, optional int border_col_rgbaIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Image(ImGui_Context ctx, ImGui_Image img, number size_w, number size_h, optional number uv0_xIn, optional number uv0_yIn, optional number uv1_xIn, optional number uv1_yIn, optional integer tint_col_rgbaIn, optional integer border_col_rgbaIn)
(ImGui_Context ctx, ImGui_Image img, Float size_w, Float size_h, Float uv0_xInOptional, Float uv0_yInOptional, Float uv1_xInOptional, Float uv1_yInOptional, Int tint_col_rgbaInOptional, Int border_col_rgbaInOptional) = ImGui_Image(ctx, img, size_w, size_h, uv0_xInOptional, uv0_yInOptional, uv1_xInOptional, uv1_yInOptional, tint_col_rgbaInOptional, border_col_rgbaInOptional)
bool ImGui_ImageButton(ImGui_Context* ctx, const char* str_id, ImGui_Image* img, double size_w, double size_h, double* uv0_xInOptional, double* uv0_yInOptional, double* uv1_xInOptional, double* uv1_yInOptional, int* bg_col_rgbaInOptional, int* tint_col_rgbaInOptional)
bool ImGui_ImageButton(ImGui_Context ctx, "str_id", ImGui_Image img, size_w, size_h, optional uv0_xIn, optional uv0_yIn, optional uv1_xIn, optional uv1_yIn, optional int bg_col_rgbaIn, optional int tint_col_rgbaIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_ImageButton", ImGui_Context ctx, "str_id", ImGui_Image img, size_w, size_h, optional uv0_xIn, optional uv0_yIn, optional uv1_xIn, optional uv1_yIn, optional int bg_col_rgbaIn, optional int tint_col_rgbaIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_ImageButton(ImGui_Context ctx, string str_id, ImGui_Image img, number size_w, number size_h, optional number uv0_xIn, optional number uv0_yIn, optional number uv1_xIn, optional number uv1_yIn, optional integer bg_col_rgbaIn, optional integer tint_col_rgbaIn)
(Boolean retval, ImGui_Context ctx, String str_id, ImGui_Image img, Float size_w, Float size_h, Float uv0_xInOptional, Float uv0_yInOptional, Float uv1_xInOptional, Float uv1_yInOptional, Int bg_col_rgbaInOptional, Int tint_col_rgbaInOptional) = ImGui_ImageButton(ctx, str_id, img, size_w, size_h, uv0_xInOptional, uv0_yInOptional, uv1_xInOptional, uv1_yInOptional, bg_col_rgbaInOptional, tint_col_rgbaInOptional)
void ImGui_ImageSet_Add(ImGui_ImageSet* set, double scale, ImGui_Image* img)
ImGui_ImageSet_Add(ImGui_ImageSet set, scale, ImGui_Image img) (requires REAPER 6.24 or later)
extension_api("ImGui_ImageSet_Add", ImGui_ImageSet set, scale, ImGui_Image img) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_ImageSet_Add(ImGui_ImageSet set, number scale, ImGui_Image img)
ImGui_ImageSet_Add(ImGui_ImageSet set, Float scale, ImGui_Image img)

'img' cannot be another ImageSet.

void ImGui_Image_GetSize(ImGui_Image* img, double* wOut, double* hOut)
ImGui_Image_GetSize(ImGui_Image img, &w, &h) (requires REAPER 6.24 or later)
extension_api("ImGui_Image_GetSize", ImGui_Image img, &w, &h) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number w, number h = reaper.ImGui_Image_GetSize(ImGui_Image img)
(ImGui_Image img, Float wOut, Float hOut) = ImGui_Image_GetSize(img, wOut, hOut)
void ImGui_Indent(ImGui_Context* ctx, double* indent_wInOptional)
ImGui_Indent(ImGui_Context ctx, optional indent_wIn) (requires REAPER 6.24 or later)
extension_api("ImGui_Indent", ImGui_Context ctx, optional indent_wIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Indent(ImGui_Context ctx, optional number indent_wIn)
(ImGui_Context ctx, Float indent_wInOptional) = ImGui_Indent(ctx, indent_wInOptional)

Move content position toward the right, by 'indent_w', or
StyleVar_IndentSpacing if 'indent_w' <= 0. See Unindent.

bool ImGui_InputDouble(ImGui_Context* ctx, const char* label, double* vInOut, double* stepInOptional, double* step_fastInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_InputDouble(ImGui_Context ctx, "label", &v, optional stepIn, optional step_fastIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputDouble", ImGui_Context ctx, "label", &v, optional stepIn, optional step_fastIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v = reaper.ImGui_InputDouble(ImGui_Context ctx, string label, number v, optional number stepIn, optional number step_fastIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float vInOut, Float stepInOptional, Float step_fastInOptional, String formatInOptional, Int flagsInOptional) = ImGui_InputDouble(ctx, label, vInOut, stepInOptional, step_fastInOptional, formatInOptional, flagsInOptional)
bool ImGui_InputDouble2(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, const char* formatInOptional, int* flagsInOptional)
bool ImGui_InputDouble2(ImGui_Context ctx, "label", &v1, &v2, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputDouble2", ImGui_Context ctx, "label", &v1, &v2, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v1, number v2 = reaper.ImGui_InputDouble2(ImGui_Context ctx, string label, number v1, number v2, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v1InOut, Float v2InOut, String formatInOptional, Int flagsInOptional) = ImGui_InputDouble2(ctx, label, v1InOut, v2InOut, formatInOptional, flagsInOptional)
bool ImGui_InputDouble3(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, const char* formatInOptional, int* flagsInOptional)
bool ImGui_InputDouble3(ImGui_Context ctx, "label", &v1, &v2, &v3, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputDouble3", ImGui_Context ctx, "label", &v1, &v2, &v3, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v1, number v2, number v3 = reaper.ImGui_InputDouble3(ImGui_Context ctx, string label, number v1, number v2, number v3, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v1InOut, Float v2InOut, Float v3InOut, String formatInOptional, Int flagsInOptional) = ImGui_InputDouble3(ctx, label, v1InOut, v2InOut, v3InOut, formatInOptional, flagsInOptional)
bool ImGui_InputDouble4(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double* v4InOut, const char* formatInOptional, int* flagsInOptional)
bool ImGui_InputDouble4(ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputDouble4", ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v1, number v2, number v3, number v4 = reaper.ImGui_InputDouble4(ImGui_Context ctx, string label, number v1, number v2, number v3, number v4, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v1InOut, Float v2InOut, Float v3InOut, Float v4InOut, String formatInOptional, Int flagsInOptional) = ImGui_InputDouble4(ctx, label, v1InOut, v2InOut, v3InOut, v4InOut, formatInOptional, flagsInOptional)
bool ImGui_InputDoubleN(ImGui_Context* ctx, const char* label, reaper_array* values, double* stepInOptional, double* step_fastInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_InputDoubleN(ImGui_Context ctx, "label", reaper_array values, optional stepIn, optional step_fastIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputDoubleN", ImGui_Context ctx, "label", reaper_array values, optional stepIn, optional step_fastIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_InputDoubleN(ImGui_Context ctx, string label, reaper_array values, optional number stepIn, optional number step_fastIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, reaper_array values, Float stepInOptional, Float step_fastInOptional, String formatInOptional, Int flagsInOptional) = ImGui_InputDoubleN(ctx, label, values, stepInOptional, step_fastInOptional, formatInOptional, flagsInOptional)
bool ImGui_InputInt(ImGui_Context* ctx, const char* label, int* vInOut, int* stepInOptional, int* step_fastInOptional, int* flagsInOptional)
bool ImGui_InputInt(ImGui_Context ctx, "label", int &v, optional int stepIn, optional int step_fastIn, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputInt", ImGui_Context ctx, "label", int &v, optional int stepIn, optional int step_fastIn, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v = reaper.ImGui_InputInt(ImGui_Context ctx, string label, integer v, optional integer stepIn, optional integer step_fastIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int vInOut, Int stepInOptional, Int step_fastInOptional, Int flagsInOptional) = ImGui_InputInt(ctx, label, vInOut, stepInOptional, step_fastInOptional, flagsInOptional)
bool ImGui_InputInt2(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* flagsInOptional)
bool ImGui_InputInt2(ImGui_Context ctx, "label", int &v1, int &v2, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputInt2", ImGui_Context ctx, "label", int &v1, int &v2, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v1, integer v2 = reaper.ImGui_InputInt2(ImGui_Context ctx, string label, integer v1, integer v2, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v1InOut, Int v2InOut, Int flagsInOptional) = ImGui_InputInt2(ctx, label, v1InOut, v2InOut, flagsInOptional)
bool ImGui_InputInt3(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int* flagsInOptional)
bool ImGui_InputInt3(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputInt3", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v1, integer v2, integer v3 = reaper.ImGui_InputInt3(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v1InOut, Int v2InOut, Int v3InOut, Int flagsInOptional) = ImGui_InputInt3(ctx, label, v1InOut, v2InOut, v3InOut, flagsInOptional)
bool ImGui_InputInt4(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int* v4InOut, int* flagsInOptional)
bool ImGui_InputInt4(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputInt4", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v1, integer v2, integer v3, integer v4 = reaper.ImGui_InputInt4(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, integer v4, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v1InOut, Int v2InOut, Int v3InOut, Int v4InOut, Int flagsInOptional) = ImGui_InputInt4(ctx, label, v1InOut, v2InOut, v3InOut, v4InOut, flagsInOptional)
bool ImGui_InputText(ImGui_Context* ctx, const char* label, char* bufInOutNeedBig, int bufInOutNeedBig_sz, int* flagsInOptional, ImGui_Function* callbackInOptional)
bool ImGui_InputText(ImGui_Context ctx, "label", #buf, optional int flagsIn, ImGui_Function callbackIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputText", ImGui_Context ctx, "label", #buf, optional int flagsIn, ImGui_Function callbackIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string buf = reaper.ImGui_InputText(ImGui_Context ctx, string label, string buf, optional integer flagsIn, ImGui_Function callbackIn)
(Boolean retval, ImGui_Context ctx, String label, String bufInOutNeedBig, Int bufInOutNeedBig_sz, Int flagsInOptional, ImGui_Function callbackInOptional) = ImGui_InputText(ctx, label, bufInOutNeedBig, bufInOutNeedBig_sz, flagsInOptional, callbackInOptional)
int ImGui_InputTextFlags_AllowTabInput()
int ImGui_InputTextFlags_AllowTabInput() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_AllowTabInput") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_AllowTabInput()
Int ImGui_InputTextFlags_AllowTabInput()

Pressing TAB input a '\t' character into the text field.

int ImGui_InputTextFlags_AlwaysOverwrite()
int ImGui_InputTextFlags_AlwaysOverwrite() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_AlwaysOverwrite") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_AlwaysOverwrite()
Int ImGui_InputTextFlags_AlwaysOverwrite()

Overwrite mode.

int ImGui_InputTextFlags_AutoSelectAll()
int ImGui_InputTextFlags_AutoSelectAll() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_AutoSelectAll") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_AutoSelectAll()
Int ImGui_InputTextFlags_AutoSelectAll()

Select entire text when first taking mouse focus.

int ImGui_InputTextFlags_CallbackAlways()
int ImGui_InputTextFlags_CallbackAlways() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CallbackAlways") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CallbackAlways()
Int ImGui_InputTextFlags_CallbackAlways()

Callback on each iteration. User code may query cursor position, modify text buffer.

int ImGui_InputTextFlags_CallbackCharFilter()
int ImGui_InputTextFlags_CallbackCharFilter() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CallbackCharFilter") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CallbackCharFilter()
Int ImGui_InputTextFlags_CallbackCharFilter()

Callback on character inputs to replace or discard them.
Modify 'EventChar' to replace or 'EventChar = 0' to discard.

int ImGui_InputTextFlags_CallbackCompletion()
int ImGui_InputTextFlags_CallbackCompletion() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CallbackCompletion") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CallbackCompletion()
Int ImGui_InputTextFlags_CallbackCompletion()

Callback on pressing TAB (for completion handling).

int ImGui_InputTextFlags_CallbackEdit()
int ImGui_InputTextFlags_CallbackEdit() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CallbackEdit") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CallbackEdit()
Int ImGui_InputTextFlags_CallbackEdit()

Callback on any edit (note that InputText() already returns true on edit,
the callback is useful mainly to manipulate the underlying buffer while
focus is active).

int ImGui_InputTextFlags_CallbackHistory()
int ImGui_InputTextFlags_CallbackHistory() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CallbackHistory") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CallbackHistory()
Int ImGui_InputTextFlags_CallbackHistory()

Callback on pressing Up/Down arrows (for history handling).

int ImGui_InputTextFlags_CharsDecimal()
int ImGui_InputTextFlags_CharsDecimal() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CharsDecimal") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CharsDecimal()
Int ImGui_InputTextFlags_CharsDecimal()

Allow 0123456789.+-*/.

int ImGui_InputTextFlags_CharsHexadecimal()
int ImGui_InputTextFlags_CharsHexadecimal() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CharsHexadecimal") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CharsHexadecimal()
Int ImGui_InputTextFlags_CharsHexadecimal()

Allow 0123456789ABCDEFabcdef.

int ImGui_InputTextFlags_CharsNoBlank()
int ImGui_InputTextFlags_CharsNoBlank() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CharsNoBlank") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CharsNoBlank()
Int ImGui_InputTextFlags_CharsNoBlank()

Filter out spaces, tabs.

int ImGui_InputTextFlags_CharsScientific()
int ImGui_InputTextFlags_CharsScientific() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CharsScientific") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CharsScientific()
Int ImGui_InputTextFlags_CharsScientific()

Allow 0123456789.+-*/eE (Scientific notation input).

int ImGui_InputTextFlags_CharsUppercase()
int ImGui_InputTextFlags_CharsUppercase() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CharsUppercase") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CharsUppercase()
Int ImGui_InputTextFlags_CharsUppercase()

Turn a..z into A..Z.

int ImGui_InputTextFlags_CtrlEnterForNewLine()
int ImGui_InputTextFlags_CtrlEnterForNewLine() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_CtrlEnterForNewLine") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_CtrlEnterForNewLine()
Int ImGui_InputTextFlags_CtrlEnterForNewLine()

In multi-line mode, unfocus with Enter, add new line with Ctrl+Enter
(default is opposite: unfocus with Ctrl+Enter, add line with Enter).

int ImGui_InputTextFlags_EnterReturnsTrue()
int ImGui_InputTextFlags_EnterReturnsTrue() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_EnterReturnsTrue") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_EnterReturnsTrue()
Int ImGui_InputTextFlags_EnterReturnsTrue()

Return 'true' when Enter is pressed (as opposed to every time the value was
modified). Consider looking at the IsItemDeactivatedAfterEdit function.

int ImGui_InputTextFlags_EscapeClearsAll()
int ImGui_InputTextFlags_EscapeClearsAll() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_EscapeClearsAll") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_EscapeClearsAll()
Int ImGui_InputTextFlags_EscapeClearsAll()

Escape key clears content if not empty, and deactivate otherwise
(constrast to default behavior of Escape to revert).

int ImGui_InputTextFlags_NoHorizontalScroll()
int ImGui_InputTextFlags_NoHorizontalScroll() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_NoHorizontalScroll") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_NoHorizontalScroll()
Int ImGui_InputTextFlags_NoHorizontalScroll()

Disable following the cursor horizontally.

int ImGui_InputTextFlags_NoUndoRedo()
int ImGui_InputTextFlags_NoUndoRedo() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_NoUndoRedo") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_NoUndoRedo()
Int ImGui_InputTextFlags_NoUndoRedo()

Disable undo/redo. Note that input text owns the text data while active.

int ImGui_InputTextFlags_None()
int ImGui_InputTextFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_None()
Int ImGui_InputTextFlags_None()
int ImGui_InputTextFlags_Password()
int ImGui_InputTextFlags_Password() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_Password") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_Password()
Int ImGui_InputTextFlags_Password()

Password mode, display all characters as '*'.

int ImGui_InputTextFlags_ReadOnly()
int ImGui_InputTextFlags_ReadOnly() (requires REAPER 6.24 or later)
int extension_api("ImGui_InputTextFlags_ReadOnly") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_InputTextFlags_ReadOnly()
Int ImGui_InputTextFlags_ReadOnly()

Read-only mode.

bool ImGui_InputTextMultiline(ImGui_Context* ctx, const char* label, char* bufInOutNeedBig, int bufInOutNeedBig_sz, double* size_wInOptional, double* size_hInOptional, int* flagsInOptional, ImGui_Function* callbackInOptional)
bool ImGui_InputTextMultiline(ImGui_Context ctx, "label", #buf, optional size_wIn, optional size_hIn, optional int flagsIn, ImGui_Function callbackIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputTextMultiline", ImGui_Context ctx, "label", #buf, optional size_wIn, optional size_hIn, optional int flagsIn, ImGui_Function callbackIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string buf = reaper.ImGui_InputTextMultiline(ImGui_Context ctx, string label, string buf, optional number size_wIn, optional number size_hIn, optional integer flagsIn, ImGui_Function callbackIn)
(Boolean retval, ImGui_Context ctx, String label, String bufInOutNeedBig, Int bufInOutNeedBig_sz, Float size_wInOptional, Float size_hInOptional, Int flagsInOptional, ImGui_Function callbackInOptional) = ImGui_InputTextMultiline(ctx, label, bufInOutNeedBig, bufInOutNeedBig_sz, size_wInOptional, size_hInOptional, flagsInOptional, callbackInOptional)
bool ImGui_InputTextWithHint(ImGui_Context* ctx, const char* label, const char* hint, char* bufInOutNeedBig, int bufInOutNeedBig_sz, int* flagsInOptional, ImGui_Function* callbackInOptional)
bool ImGui_InputTextWithHint(ImGui_Context ctx, "label", "hint", #buf, optional int flagsIn, ImGui_Function callbackIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InputTextWithHint", ImGui_Context ctx, "label", "hint", #buf, optional int flagsIn, ImGui_Function callbackIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string buf = reaper.ImGui_InputTextWithHint(ImGui_Context ctx, string label, string hint, string buf, optional integer flagsIn, ImGui_Function callbackIn)
(Boolean retval, ImGui_Context ctx, String label, String hint, String bufInOutNeedBig, Int bufInOutNeedBig_sz, Int flagsInOptional, ImGui_Function callbackInOptional) = ImGui_InputTextWithHint(ctx, label, hint, bufInOutNeedBig, bufInOutNeedBig_sz, flagsInOptional, callbackInOptional)
bool ImGui_InvisibleButton(ImGui_Context* ctx, const char* str_id, double size_w, double size_h, int* flagsInOptional)
bool ImGui_InvisibleButton(ImGui_Context ctx, "str_id", size_w, size_h, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_InvisibleButton", ImGui_Context ctx, "str_id", size_w, size_h, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_InvisibleButton(ImGui_Context ctx, string str_id, number size_w, number size_h, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String str_id, Float size_w, Float size_h, Int flagsInOptional) = ImGui_InvisibleButton(ctx, str_id, size_w, size_h, flagsInOptional)

Flexible button behavior without the visuals, frequently useful to build
custom behaviors using the public api (along with IsItemActive, IsItemHovered, etc.).

bool ImGui_IsAnyItemActive(ImGui_Context* ctx)
bool ImGui_IsAnyItemActive(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsAnyItemActive", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsAnyItemActive(ImGui_Context ctx)
Boolean ImGui_IsAnyItemActive(ImGui_Context ctx)
bool ImGui_IsAnyItemFocused(ImGui_Context* ctx)
bool ImGui_IsAnyItemFocused(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsAnyItemFocused", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsAnyItemFocused(ImGui_Context ctx)
Boolean ImGui_IsAnyItemFocused(ImGui_Context ctx)
bool ImGui_IsAnyItemHovered(ImGui_Context* ctx)
bool ImGui_IsAnyItemHovered(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsAnyItemHovered", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsAnyItemHovered(ImGui_Context ctx)
Boolean ImGui_IsAnyItemHovered(ImGui_Context ctx)
bool ImGui_IsAnyMouseDown(ImGui_Context* ctx)
bool ImGui_IsAnyMouseDown(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsAnyMouseDown", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsAnyMouseDown(ImGui_Context ctx)
Boolean ImGui_IsAnyMouseDown(ImGui_Context ctx)

Is any mouse button held?

bool ImGui_IsItemActivated(ImGui_Context* ctx)
bool ImGui_IsItemActivated(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemActivated", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemActivated(ImGui_Context ctx)
Boolean ImGui_IsItemActivated(ImGui_Context ctx)

Was the last item just made active (item was previously inactive).

bool ImGui_IsItemActive(ImGui_Context* ctx)
bool ImGui_IsItemActive(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemActive", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemActive(ImGui_Context ctx)
Boolean ImGui_IsItemActive(ImGui_Context ctx)

Is the last item active? (e.g. button being held, text field being edited.
This will continuously return true while holding mouse button on an item.
Items that don't interact will always return false.

bool ImGui_IsItemClicked(ImGui_Context* ctx, int* mouse_buttonInOptional)
bool ImGui_IsItemClicked(ImGui_Context ctx, optional int mouse_buttonIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemClicked", ImGui_Context ctx, optional int mouse_buttonIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemClicked(ImGui_Context ctx, optional integer mouse_buttonIn)
(Boolean retval, ImGui_Context ctx, Int mouse_buttonInOptional) = ImGui_IsItemClicked(ctx, mouse_buttonInOptional)

Is the last item clicked? (e.g. button/node just clicked on)
== IsMouseClicked(mouse_button) && IsItemHovered().

This is NOT equivalent to the behavior of e.g. Button.
Most widgets have specific reactions based on mouse-up/down state, mouse position etc.

bool ImGui_IsItemDeactivated(ImGui_Context* ctx)
bool ImGui_IsItemDeactivated(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemDeactivated", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemDeactivated(ImGui_Context ctx)
Boolean ImGui_IsItemDeactivated(ImGui_Context ctx)

Was the last item just made inactive (item was previously active).
Useful for Undo/Redo patterns with widgets that require continuous editing.

bool ImGui_IsItemDeactivatedAfterEdit(ImGui_Context* ctx)
bool ImGui_IsItemDeactivatedAfterEdit(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemDeactivatedAfterEdit", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemDeactivatedAfterEdit(ImGui_Context ctx)
Boolean ImGui_IsItemDeactivatedAfterEdit(ImGui_Context ctx)

Was the last item just made inactive and made a value change when it was
active? (e.g. Slider/Drag moved).

Useful for Undo/Redo patterns with widgets that require continuous editing. Note
that you may get false positives (some widgets such as Combo/ListBox/Selectable
will return true even when clicking an already selected item).

bool ImGui_IsItemEdited(ImGui_Context* ctx)
bool ImGui_IsItemEdited(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemEdited", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemEdited(ImGui_Context ctx)
Boolean ImGui_IsItemEdited(ImGui_Context ctx)

Did the last item modify its underlying value this frame? or was pressed?
This is generally the same as the "bool" return value of many widgets.

bool ImGui_IsItemFocused(ImGui_Context* ctx)
bool ImGui_IsItemFocused(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemFocused", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemFocused(ImGui_Context ctx)
Boolean ImGui_IsItemFocused(ImGui_Context ctx)

Is the last item focused for keyboard/gamepad navigation?

bool ImGui_IsItemHovered(ImGui_Context* ctx, int* flagsInOptional)
bool ImGui_IsItemHovered(ImGui_Context ctx, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemHovered", ImGui_Context ctx, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemHovered(ImGui_Context ctx, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, Int flagsInOptional) = ImGui_IsItemHovered(ctx, flagsInOptional)

Is the last item hovered? (and usable, aka not blocked by a popup, etc.).
See HoveredFlags_* for more options.

bool ImGui_IsItemToggledOpen(ImGui_Context* ctx)
bool ImGui_IsItemToggledOpen(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemToggledOpen", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemToggledOpen(ImGui_Context ctx)
Boolean ImGui_IsItemToggledOpen(ImGui_Context ctx)

Was the last item open state toggled? Set by TreeNode.

bool ImGui_IsItemVisible(ImGui_Context* ctx)
bool ImGui_IsItemVisible(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsItemVisible", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsItemVisible(ImGui_Context ctx)
Boolean ImGui_IsItemVisible(ImGui_Context ctx)

Is the last item visible? (items may be out of sight because of clipping/scrolling)

bool ImGui_IsKeyDown(ImGui_Context* ctx, int key)
bool ImGui_IsKeyDown(ImGui_Context ctx, int key) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsKeyDown", ImGui_Context ctx, int key) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsKeyDown(ImGui_Context ctx, integer key)
Boolean ImGui_IsKeyDown(ImGui_Context ctx, Int key)

Is key being held.

bool ImGui_IsKeyPressed(ImGui_Context* ctx, int key, bool* repeatInOptional)
bool ImGui_IsKeyPressed(ImGui_Context ctx, int key, optional bool repeatIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsKeyPressed", ImGui_Context ctx, int key, optional bool repeatIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsKeyPressed(ImGui_Context ctx, integer key, optional boolean repeatIn)
(Boolean retval, ImGui_Context ctx, Int key, Boolean repeatInOptional) = ImGui_IsKeyPressed(ctx, key, repeatInOptional)

Was key pressed (went from !Down to Down)?
If repeat=true, uses ConfigVar_KeyRepeatDelay / ConfigVar_KeyRepeatRate.

bool ImGui_IsKeyReleased(ImGui_Context* ctx, int key)
bool ImGui_IsKeyReleased(ImGui_Context ctx, int key) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsKeyReleased", ImGui_Context ctx, int key) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsKeyReleased(ImGui_Context ctx, integer key)
Boolean ImGui_IsKeyReleased(ImGui_Context ctx, Int key)

Was key released (went from Down to !Down)?

bool ImGui_IsMouseClicked(ImGui_Context* ctx, int button, bool* repeatInOptional)
bool ImGui_IsMouseClicked(ImGui_Context ctx, int button, optional bool repeatIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsMouseClicked", ImGui_Context ctx, int button, optional bool repeatIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsMouseClicked(ImGui_Context ctx, integer button, optional boolean repeatIn)
(Boolean retval, ImGui_Context ctx, Int button, Boolean repeatInOptional) = ImGui_IsMouseClicked(ctx, button, repeatInOptional)

Did mouse button clicked? (went from !Down to Down).
Same as GetMouseClickedCount() == 1.

bool ImGui_IsMouseDoubleClicked(ImGui_Context* ctx, int button)
bool ImGui_IsMouseDoubleClicked(ImGui_Context ctx, int button) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsMouseDoubleClicked", ImGui_Context ctx, int button) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsMouseDoubleClicked(ImGui_Context ctx, integer button)
Boolean ImGui_IsMouseDoubleClicked(ImGui_Context ctx, Int button)

Did mouse button double-clicked? Same as GetMouseClickedCount() == 2.
(Note that a double-click will also report IsMouseClicked() == true)

bool ImGui_IsMouseDown(ImGui_Context* ctx, int button)
bool ImGui_IsMouseDown(ImGui_Context ctx, int button) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsMouseDown", ImGui_Context ctx, int button) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsMouseDown(ImGui_Context ctx, integer button)
Boolean ImGui_IsMouseDown(ImGui_Context ctx, Int button)

Is mouse button held?

bool ImGui_IsMouseDragging(ImGui_Context* ctx, int button, double* lock_thresholdInOptional)
bool ImGui_IsMouseDragging(ImGui_Context ctx, int button, optional lock_thresholdIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsMouseDragging", ImGui_Context ctx, int button, optional lock_thresholdIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsMouseDragging(ImGui_Context ctx, integer button, optional number lock_thresholdIn)
(Boolean retval, ImGui_Context ctx, Int button, Float lock_thresholdInOptional) = ImGui_IsMouseDragging(ctx, button, lock_thresholdInOptional)

Is mouse dragging? (if lock_threshold < -1.0, uses ConfigVar_MouseDragThreshold)

bool ImGui_IsMouseHoveringRect(ImGui_Context* ctx, double r_min_x, double r_min_y, double r_max_x, double r_max_y, bool* clipInOptional)
bool ImGui_IsMouseHoveringRect(ImGui_Context ctx, r_min_x, r_min_y, r_max_x, r_max_y, optional bool clipIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsMouseHoveringRect", ImGui_Context ctx, r_min_x, r_min_y, r_max_x, r_max_y, optional bool clipIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsMouseHoveringRect(ImGui_Context ctx, number r_min_x, number r_min_y, number r_max_x, number r_max_y, optional boolean clipIn)
(Boolean retval, ImGui_Context ctx, Float r_min_x, Float r_min_y, Float r_max_x, Float r_max_y, Boolean clipInOptional) = ImGui_IsMouseHoveringRect(ctx, r_min_x, r_min_y, r_max_x, r_max_y, clipInOptional)

Is mouse hovering given bounding rect (in screen space).
Clipped by current clipping settings, but disregarding of other consideration
of focus/window ordering/popup-block.

bool ImGui_IsMousePosValid(ImGui_Context* ctx, double* mouse_pos_xInOptional, double* mouse_pos_yInOptional)
bool ImGui_IsMousePosValid(ImGui_Context ctx, optional mouse_pos_xIn, optional mouse_pos_yIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsMousePosValid", ImGui_Context ctx, optional mouse_pos_xIn, optional mouse_pos_yIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsMousePosValid(ImGui_Context ctx, optional number mouse_pos_xIn, optional number mouse_pos_yIn)
(Boolean retval, ImGui_Context ctx, Float mouse_pos_xInOptional, Float mouse_pos_yInOptional) = ImGui_IsMousePosValid(ctx, mouse_pos_xInOptional, mouse_pos_yInOptional)
bool ImGui_IsMouseReleased(ImGui_Context* ctx, int button)
bool ImGui_IsMouseReleased(ImGui_Context ctx, int button) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsMouseReleased", ImGui_Context ctx, int button) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsMouseReleased(ImGui_Context ctx, integer button)
Boolean ImGui_IsMouseReleased(ImGui_Context ctx, Int button)

Did mouse button released? (went from Down to !Down)

bool ImGui_IsPopupOpen(ImGui_Context* ctx, const char* str_id, int* flagsInOptional)
bool ImGui_IsPopupOpen(ImGui_Context ctx, "str_id", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsPopupOpen", ImGui_Context ctx, "str_id", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsPopupOpen(ImGui_Context ctx, string str_id, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String str_id, Int flagsInOptional) = ImGui_IsPopupOpen(ctx, str_id, flagsInOptional)

Return true if the popup is open at the current BeginPopup level of the
popup stack.

- With PopupFlags_AnyPopupId: return true if any popup is open at the current
BeginPopup() level of the popup stack.
- With PopupFlags_AnyPopupId + PopupFlags_AnyPopupLevel: return true if any
popup is open.

bool ImGui_IsRectVisible(ImGui_Context* ctx, double size_w, double size_h)
bool ImGui_IsRectVisible(ImGui_Context ctx, size_w, size_h) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsRectVisible", ImGui_Context ctx, size_w, size_h) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsRectVisible(ImGui_Context ctx, number size_w, number size_h)
Boolean ImGui_IsRectVisible(ImGui_Context ctx, Float size_w, Float size_h)

Test if rectangle (of given size, starting from cursor position) is
visible / not clipped.

bool ImGui_IsRectVisibleEx(ImGui_Context* ctx, double rect_min_x, double rect_min_y, double rect_max_x, double rect_max_y)
bool ImGui_IsRectVisibleEx(ImGui_Context ctx, rect_min_x, rect_min_y, rect_max_x, rect_max_y) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsRectVisibleEx", ImGui_Context ctx, rect_min_x, rect_min_y, rect_max_x, rect_max_y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsRectVisibleEx(ImGui_Context ctx, number rect_min_x, number rect_min_y, number rect_max_x, number rect_max_y)
Boolean ImGui_IsRectVisibleEx(ImGui_Context ctx, Float rect_min_x, Float rect_min_y, Float rect_max_x, Float rect_max_y)

Test if rectangle (in screen space) is visible / not clipped. to perform
coarse clipping on user's side.

bool ImGui_IsWindowAppearing(ImGui_Context* ctx)
bool ImGui_IsWindowAppearing(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsWindowAppearing", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsWindowAppearing(ImGui_Context ctx)
Boolean ImGui_IsWindowAppearing(ImGui_Context ctx)

Use after Begin/BeginPopup/BeginPopupModal to tell if a window just opened.

bool ImGui_IsWindowDocked(ImGui_Context* ctx)
bool ImGui_IsWindowDocked(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsWindowDocked", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsWindowDocked(ImGui_Context ctx)
Boolean ImGui_IsWindowDocked(ImGui_Context ctx)

Is current window docked into another window or a REAPER docker?

bool ImGui_IsWindowFocused(ImGui_Context* ctx, int* flagsInOptional)
bool ImGui_IsWindowFocused(ImGui_Context ctx, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsWindowFocused", ImGui_Context ctx, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsWindowFocused(ImGui_Context ctx, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, Int flagsInOptional) = ImGui_IsWindowFocused(ctx, flagsInOptional)

Is current window focused? or its root/child, depending on flags.
See flags for options.

bool ImGui_IsWindowHovered(ImGui_Context* ctx, int* flagsInOptional)
bool ImGui_IsWindowHovered(ImGui_Context ctx, optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_IsWindowHovered", ImGui_Context ctx, optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_IsWindowHovered(ImGui_Context ctx, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, Int flagsInOptional) = ImGui_IsWindowHovered(ctx, flagsInOptional)

Is current window hovered (and typically: not blocked by a popup/modal)?
See flags for options.

int ImGui_Key_0()
int ImGui_Key_0() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_0") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_0()
Int ImGui_Key_0()
int ImGui_Key_1()
int ImGui_Key_1() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_1") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_1()
Int ImGui_Key_1()
int ImGui_Key_2()
int ImGui_Key_2() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_2") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_2()
Int ImGui_Key_2()
int ImGui_Key_3()
int ImGui_Key_3() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_3") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_3()
Int ImGui_Key_3()
int ImGui_Key_4()
int ImGui_Key_4() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_4") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_4()
Int ImGui_Key_4()
int ImGui_Key_5()
int ImGui_Key_5() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_5") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_5()
Int ImGui_Key_5()
int ImGui_Key_6()
int ImGui_Key_6() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_6") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_6()
Int ImGui_Key_6()
int ImGui_Key_7()
int ImGui_Key_7() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_7") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_7()
Int ImGui_Key_7()
int ImGui_Key_8()
int ImGui_Key_8() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_8") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_8()
Int ImGui_Key_8()
int ImGui_Key_9()
int ImGui_Key_9() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_9") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_9()
Int ImGui_Key_9()
int ImGui_Key_A()
int ImGui_Key_A() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_A") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_A()
Int ImGui_Key_A()
int ImGui_Key_Apostrophe()
int ImGui_Key_Apostrophe() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Apostrophe") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Apostrophe()
Int ImGui_Key_Apostrophe()

'

int ImGui_Key_B()
int ImGui_Key_B() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_B") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_B()
Int ImGui_Key_B()
int ImGui_Key_Backslash()
int ImGui_Key_Backslash() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Backslash") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Backslash()
Int ImGui_Key_Backslash()

\

int ImGui_Key_Backspace()
int ImGui_Key_Backspace() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Backspace") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Backspace()
Int ImGui_Key_Backspace()
int ImGui_Key_C()
int ImGui_Key_C() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_C") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_C()
Int ImGui_Key_C()
int ImGui_Key_CapsLock()
int ImGui_Key_CapsLock() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_CapsLock") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_CapsLock()
Int ImGui_Key_CapsLock()
int ImGui_Key_Comma()
int ImGui_Key_Comma() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Comma") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Comma()
Int ImGui_Key_Comma()

,

int ImGui_Key_D()
int ImGui_Key_D() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_D") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_D()
Int ImGui_Key_D()
int ImGui_Key_Delete()
int ImGui_Key_Delete() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Delete") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Delete()
Int ImGui_Key_Delete()
int ImGui_Key_DownArrow()
int ImGui_Key_DownArrow() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_DownArrow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_DownArrow()
Int ImGui_Key_DownArrow()
int ImGui_Key_E()
int ImGui_Key_E() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_E") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_E()
Int ImGui_Key_E()
int ImGui_Key_End()
int ImGui_Key_End() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_End") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_End()
Int ImGui_Key_End()
int ImGui_Key_Enter()
int ImGui_Key_Enter() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Enter") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Enter()
Int ImGui_Key_Enter()
int ImGui_Key_Equal()
int ImGui_Key_Equal() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Equal") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Equal()
Int ImGui_Key_Equal()

=

int ImGui_Key_Escape()
int ImGui_Key_Escape() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Escape") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Escape()
Int ImGui_Key_Escape()
int ImGui_Key_F()
int ImGui_Key_F() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F()
Int ImGui_Key_F()
int ImGui_Key_F1()
int ImGui_Key_F1() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F1") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F1()
Int ImGui_Key_F1()
int ImGui_Key_F10()
int ImGui_Key_F10() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F10") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F10()
Int ImGui_Key_F10()
int ImGui_Key_F11()
int ImGui_Key_F11() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F11") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F11()
Int ImGui_Key_F11()
int ImGui_Key_F12()
int ImGui_Key_F12() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F12") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F12()
Int ImGui_Key_F12()
int ImGui_Key_F2()
int ImGui_Key_F2() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F2") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F2()
Int ImGui_Key_F2()
int ImGui_Key_F3()
int ImGui_Key_F3() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F3") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F3()
Int ImGui_Key_F3()
int ImGui_Key_F4()
int ImGui_Key_F4() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F4") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F4()
Int ImGui_Key_F4()
int ImGui_Key_F5()
int ImGui_Key_F5() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F5") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F5()
Int ImGui_Key_F5()
int ImGui_Key_F6()
int ImGui_Key_F6() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F6") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F6()
Int ImGui_Key_F6()
int ImGui_Key_F7()
int ImGui_Key_F7() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F7") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F7()
Int ImGui_Key_F7()
int ImGui_Key_F8()
int ImGui_Key_F8() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F8") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F8()
Int ImGui_Key_F8()
int ImGui_Key_F9()
int ImGui_Key_F9() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_F9") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_F9()
Int ImGui_Key_F9()
int ImGui_Key_G()
int ImGui_Key_G() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_G") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_G()
Int ImGui_Key_G()
int ImGui_Key_GraveAccent()
int ImGui_Key_GraveAccent() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_GraveAccent") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_GraveAccent()
Int ImGui_Key_GraveAccent()

`

int ImGui_Key_H()
int ImGui_Key_H() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_H") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_H()
Int ImGui_Key_H()
int ImGui_Key_Home()
int ImGui_Key_Home() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Home") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Home()
Int ImGui_Key_Home()
int ImGui_Key_I()
int ImGui_Key_I() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_I") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_I()
Int ImGui_Key_I()
int ImGui_Key_Insert()
int ImGui_Key_Insert() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Insert") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Insert()
Int ImGui_Key_Insert()
int ImGui_Key_J()
int ImGui_Key_J() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_J") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_J()
Int ImGui_Key_J()
int ImGui_Key_K()
int ImGui_Key_K() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_K") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_K()
Int ImGui_Key_K()
int ImGui_Key_Keypad0()
int ImGui_Key_Keypad0() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad0") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad0()
Int ImGui_Key_Keypad0()
int ImGui_Key_Keypad1()
int ImGui_Key_Keypad1() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad1") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad1()
Int ImGui_Key_Keypad1()
int ImGui_Key_Keypad2()
int ImGui_Key_Keypad2() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad2") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad2()
Int ImGui_Key_Keypad2()
int ImGui_Key_Keypad3()
int ImGui_Key_Keypad3() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad3") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad3()
Int ImGui_Key_Keypad3()
int ImGui_Key_Keypad4()
int ImGui_Key_Keypad4() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad4") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad4()
Int ImGui_Key_Keypad4()
int ImGui_Key_Keypad5()
int ImGui_Key_Keypad5() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad5") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad5()
Int ImGui_Key_Keypad5()
int ImGui_Key_Keypad6()
int ImGui_Key_Keypad6() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad6") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad6()
Int ImGui_Key_Keypad6()
int ImGui_Key_Keypad7()
int ImGui_Key_Keypad7() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad7") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad7()
Int ImGui_Key_Keypad7()
int ImGui_Key_Keypad8()
int ImGui_Key_Keypad8() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad8") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad8()
Int ImGui_Key_Keypad8()
int ImGui_Key_Keypad9()
int ImGui_Key_Keypad9() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Keypad9") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Keypad9()
Int ImGui_Key_Keypad9()
int ImGui_Key_KeypadAdd()
int ImGui_Key_KeypadAdd() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_KeypadAdd") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_KeypadAdd()
Int ImGui_Key_KeypadAdd()
int ImGui_Key_KeypadDecimal()
int ImGui_Key_KeypadDecimal() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_KeypadDecimal") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_KeypadDecimal()
Int ImGui_Key_KeypadDecimal()
int ImGui_Key_KeypadDivide()
int ImGui_Key_KeypadDivide() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_KeypadDivide") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_KeypadDivide()
Int ImGui_Key_KeypadDivide()
int ImGui_Key_KeypadEnter()
int ImGui_Key_KeypadEnter() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_KeypadEnter") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_KeypadEnter()
Int ImGui_Key_KeypadEnter()
int ImGui_Key_KeypadEqual()
int ImGui_Key_KeypadEqual() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_KeypadEqual") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_KeypadEqual()
Int ImGui_Key_KeypadEqual()
int ImGui_Key_KeypadMultiply()
int ImGui_Key_KeypadMultiply() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_KeypadMultiply") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_KeypadMultiply()
Int ImGui_Key_KeypadMultiply()
int ImGui_Key_KeypadSubtract()
int ImGui_Key_KeypadSubtract() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_KeypadSubtract") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_KeypadSubtract()
Int ImGui_Key_KeypadSubtract()
int ImGui_Key_L()
int ImGui_Key_L() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_L") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_L()
Int ImGui_Key_L()
int ImGui_Key_LeftAlt()
int ImGui_Key_LeftAlt() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_LeftAlt") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_LeftAlt()
Int ImGui_Key_LeftAlt()
int ImGui_Key_LeftArrow()
int ImGui_Key_LeftArrow() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_LeftArrow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_LeftArrow()
Int ImGui_Key_LeftArrow()
int ImGui_Key_LeftBracket()
int ImGui_Key_LeftBracket() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_LeftBracket") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_LeftBracket()
Int ImGui_Key_LeftBracket()

[

int ImGui_Key_LeftCtrl()
int ImGui_Key_LeftCtrl() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_LeftCtrl") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_LeftCtrl()
Int ImGui_Key_LeftCtrl()
int ImGui_Key_LeftShift()
int ImGui_Key_LeftShift() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_LeftShift") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_LeftShift()
Int ImGui_Key_LeftShift()
int ImGui_Key_LeftSuper()
int ImGui_Key_LeftSuper() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_LeftSuper") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_LeftSuper()
Int ImGui_Key_LeftSuper()
int ImGui_Key_M()
int ImGui_Key_M() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_M") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_M()
Int ImGui_Key_M()
int ImGui_Key_Menu()
int ImGui_Key_Menu() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Menu") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Menu()
Int ImGui_Key_Menu()
int ImGui_Key_Minus()
int ImGui_Key_Minus() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Minus") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Minus()
Int ImGui_Key_Minus()

-

int ImGui_Key_MouseLeft()
int ImGui_Key_MouseLeft() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_MouseLeft") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_MouseLeft()
Int ImGui_Key_MouseLeft()
int ImGui_Key_MouseMiddle()
int ImGui_Key_MouseMiddle() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_MouseMiddle") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_MouseMiddle()
Int ImGui_Key_MouseMiddle()
int ImGui_Key_MouseRight()
int ImGui_Key_MouseRight() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_MouseRight") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_MouseRight()
Int ImGui_Key_MouseRight()
int ImGui_Key_MouseWheelX()
int ImGui_Key_MouseWheelX() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_MouseWheelX") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_MouseWheelX()
Int ImGui_Key_MouseWheelX()
int ImGui_Key_MouseWheelY()
int ImGui_Key_MouseWheelY() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_MouseWheelY") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_MouseWheelY()
Int ImGui_Key_MouseWheelY()
int ImGui_Key_MouseX1()
int ImGui_Key_MouseX1() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_MouseX1") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_MouseX1()
Int ImGui_Key_MouseX1()
int ImGui_Key_MouseX2()
int ImGui_Key_MouseX2() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_MouseX2") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_MouseX2()
Int ImGui_Key_MouseX2()
int ImGui_Key_N()
int ImGui_Key_N() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_N") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_N()
Int ImGui_Key_N()
int ImGui_Key_NumLock()
int ImGui_Key_NumLock() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_NumLock") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_NumLock()
Int ImGui_Key_NumLock()
int ImGui_Key_O()
int ImGui_Key_O() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_O") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_O()
Int ImGui_Key_O()
int ImGui_Key_P()
int ImGui_Key_P() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_P") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_P()
Int ImGui_Key_P()
int ImGui_Key_PageDown()
int ImGui_Key_PageDown() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_PageDown") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_PageDown()
Int ImGui_Key_PageDown()
int ImGui_Key_PageUp()
int ImGui_Key_PageUp() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_PageUp") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_PageUp()
Int ImGui_Key_PageUp()
int ImGui_Key_Pause()
int ImGui_Key_Pause() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Pause") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Pause()
Int ImGui_Key_Pause()
int ImGui_Key_Period()
int ImGui_Key_Period() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Period") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Period()
Int ImGui_Key_Period()

.

int ImGui_Key_PrintScreen()
int ImGui_Key_PrintScreen() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_PrintScreen") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_PrintScreen()
Int ImGui_Key_PrintScreen()
int ImGui_Key_Q()
int ImGui_Key_Q() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Q") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Q()
Int ImGui_Key_Q()
int ImGui_Key_R()
int ImGui_Key_R() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_R") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_R()
Int ImGui_Key_R()
int ImGui_Key_RightAlt()
int ImGui_Key_RightAlt() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_RightAlt") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_RightAlt()
Int ImGui_Key_RightAlt()
int ImGui_Key_RightArrow()
int ImGui_Key_RightArrow() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_RightArrow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_RightArrow()
Int ImGui_Key_RightArrow()
int ImGui_Key_RightBracket()
int ImGui_Key_RightBracket() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_RightBracket") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_RightBracket()
Int ImGui_Key_RightBracket()

]

int ImGui_Key_RightCtrl()
int ImGui_Key_RightCtrl() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_RightCtrl") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_RightCtrl()
Int ImGui_Key_RightCtrl()
int ImGui_Key_RightShift()
int ImGui_Key_RightShift() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_RightShift") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_RightShift()
Int ImGui_Key_RightShift()
int ImGui_Key_RightSuper()
int ImGui_Key_RightSuper() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_RightSuper") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_RightSuper()
Int ImGui_Key_RightSuper()
int ImGui_Key_S()
int ImGui_Key_S() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_S") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_S()
Int ImGui_Key_S()
int ImGui_Key_ScrollLock()
int ImGui_Key_ScrollLock() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_ScrollLock") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_ScrollLock()
Int ImGui_Key_ScrollLock()
int ImGui_Key_Semicolon()
int ImGui_Key_Semicolon() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Semicolon") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Semicolon()
Int ImGui_Key_Semicolon()

;

int ImGui_Key_Slash()
int ImGui_Key_Slash() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Slash") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Slash()
Int ImGui_Key_Slash()

/

int ImGui_Key_Space()
int ImGui_Key_Space() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Space") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Space()
Int ImGui_Key_Space()
int ImGui_Key_T()
int ImGui_Key_T() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_T") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_T()
Int ImGui_Key_T()
int ImGui_Key_Tab()
int ImGui_Key_Tab() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Tab") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Tab()
Int ImGui_Key_Tab()
int ImGui_Key_U()
int ImGui_Key_U() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_U") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_U()
Int ImGui_Key_U()
int ImGui_Key_UpArrow()
int ImGui_Key_UpArrow() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_UpArrow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_UpArrow()
Int ImGui_Key_UpArrow()
int ImGui_Key_V()
int ImGui_Key_V() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_V") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_V()
Int ImGui_Key_V()
int ImGui_Key_W()
int ImGui_Key_W() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_W") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_W()
Int ImGui_Key_W()
int ImGui_Key_X()
int ImGui_Key_X() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_X") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_X()
Int ImGui_Key_X()
int ImGui_Key_Y()
int ImGui_Key_Y() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Y") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Y()
Int ImGui_Key_Y()
int ImGui_Key_Z()
int ImGui_Key_Z() (requires REAPER 6.24 or later)
int extension_api("ImGui_Key_Z") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Key_Z()
Int ImGui_Key_Z()
void ImGui_LabelText(ImGui_Context* ctx, const char* label, const char* text)
ImGui_LabelText(ImGui_Context ctx, "label", "text") (requires REAPER 6.24 or later)
extension_api("ImGui_LabelText", ImGui_Context ctx, "label", "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_LabelText(ImGui_Context ctx, string label, string text)
ImGui_LabelText(ImGui_Context ctx, String label, String text)

Display text+label aligned the same way as value+label widgets

bool ImGui_ListBox(ImGui_Context* ctx, const char* label, int* current_itemInOut, const char* items, int items_sz, int* height_in_itemsInOptional)
bool ImGui_ListBox(ImGui_Context ctx, "label", int &current_item, "items", optional int height_in_itemsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_ListBox", ImGui_Context ctx, "label", int &current_item, "items", optional int height_in_itemsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer current_item = reaper.ImGui_ListBox(ImGui_Context ctx, string label, integer current_item, string items, optional integer height_in_itemsIn)
(Boolean retval, ImGui_Context ctx, String label, Int current_itemInOut, String items, Int items_sz, Int height_in_itemsInOptional) = ImGui_ListBox(ctx, label, current_itemInOut, items, items_sz, height_in_itemsInOptional)

This is an helper over BeginListBox/EndListBox for convenience purpose.

Each item must be null-terminated (requires REAPER v6.44 or newer for EEL and Lua).

void ImGui_ListClipper_Begin(ImGui_ListClipper* clipper, int items_count, double* items_heightInOptional)
ImGui_ListClipper_Begin(ImGui_ListClipper clipper, int items_count, optional items_heightIn) (requires REAPER 6.24 or later)
extension_api("ImGui_ListClipper_Begin", ImGui_ListClipper clipper, int items_count, optional items_heightIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_ListClipper_Begin(ImGui_ListClipper clipper, integer items_count, optional number items_heightIn)
(ImGui_ListClipper clipper, Int items_count, Float items_heightInOptional) = ImGui_ListClipper_Begin(clipper, items_count, items_heightInOptional)

- items_count: Use INT_MAX if you don't know how many items you have
(in which case the cursor won't be advanced in the final step)
- items_height: Use -1.0 to be calculated automatically on first step.
Otherwise pass in the distance between your items, typically
GetTextLineHeightWithSpacing or GetFrameHeightWithSpacing.

void ImGui_ListClipper_End(ImGui_ListClipper* clipper)
ImGui_ListClipper_End(ImGui_ListClipper clipper) (requires REAPER 6.24 or later)
extension_api("ImGui_ListClipper_End", ImGui_ListClipper clipper) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_ListClipper_End(ImGui_ListClipper clipper)
ImGui_ListClipper_End(ImGui_ListClipper clipper)

Automatically called on the last call of ListClipper_Step that returns false.

void ImGui_ListClipper_GetDisplayRange(ImGui_ListClipper* clipper, int* display_startOut, int* display_endOut)
ImGui_ListClipper_GetDisplayRange(ImGui_ListClipper clipper, int &display_start, int &display_end) (requires REAPER 6.24 or later)
extension_api("ImGui_ListClipper_GetDisplayRange", ImGui_ListClipper clipper, int &display_start, int &display_end) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer display_start, integer display_end = reaper.ImGui_ListClipper_GetDisplayRange(ImGui_ListClipper clipper)
(ImGui_ListClipper clipper, Int display_startOut, Int display_endOut) = ImGui_ListClipper_GetDisplayRange(clipper, display_startOut, display_endOut)
void ImGui_ListClipper_IncludeRangeByIndices(ImGui_ListClipper* clipper, int item_begin, int item_end)
ImGui_ListClipper_IncludeRangeByIndices(ImGui_ListClipper clipper, int item_begin, int item_end) (requires REAPER 6.24 or later)
extension_api("ImGui_ListClipper_IncludeRangeByIndices", ImGui_ListClipper clipper, int item_begin, int item_end) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_ListClipper_IncludeRangeByIndices(ImGui_ListClipper clipper, integer item_begin, integer item_end)
ImGui_ListClipper_IncludeRangeByIndices(ImGui_ListClipper clipper, Int item_begin, Int item_end)

Call ListClipper_IncludeRangeByIndices before first call to
ListClipper_Step if you need a range of items to be displayed regardless of
visibility.

(Due to alignment / padding of certain items it is possible that an extra item may be included on either end of the display range).

item_end is exclusive e.g. use (42, 42+1) to make item 42 never clipped.

bool ImGui_ListClipper_Step(ImGui_ListClipper* clipper)
bool ImGui_ListClipper_Step(ImGui_ListClipper clipper) (requires REAPER 6.24 or later)
bool extension_api("ImGui_ListClipper_Step", ImGui_ListClipper clipper) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_ListClipper_Step(ImGui_ListClipper clipper)
Boolean ImGui_ListClipper_Step(ImGui_ListClipper clipper)

Call until it returns false. The display_start/display_end fields from
ListClipper_GetDisplayRange will be set and you can process/draw those items.

void ImGui_LogFinish(ImGui_Context* ctx)
ImGui_LogFinish(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_LogFinish", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_LogFinish(ImGui_Context ctx)
ImGui_LogFinish(ImGui_Context ctx)

Stop logging (close file, etc.)

void ImGui_LogText(ImGui_Context* ctx, const char* text)
ImGui_LogText(ImGui_Context ctx, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_LogText", ImGui_Context ctx, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_LogText(ImGui_Context ctx, string text)
ImGui_LogText(ImGui_Context ctx, String text)

Pass text data straight to log (without being displayed)

void ImGui_LogToClipboard(ImGui_Context* ctx, int* auto_open_depthInOptional)
ImGui_LogToClipboard(ImGui_Context ctx, optional int auto_open_depthIn) (requires REAPER 6.24 or later)
extension_api("ImGui_LogToClipboard", ImGui_Context ctx, optional int auto_open_depthIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_LogToClipboard(ImGui_Context ctx, optional integer auto_open_depthIn)
(ImGui_Context ctx, Int auto_open_depthInOptional) = ImGui_LogToClipboard(ctx, auto_open_depthInOptional)

Start logging all text output from the interface to the OS clipboard.
See also SetClipboardText.

void ImGui_LogToFile(ImGui_Context* ctx, int* auto_open_depthInOptional, const char* filenameInOptional)
ImGui_LogToFile(ImGui_Context ctx, optional int auto_open_depthIn, optional "filenameIn") (requires REAPER 6.24 or later)
extension_api("ImGui_LogToFile", ImGui_Context ctx, optional int auto_open_depthIn, optional "filenameIn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_LogToFile(ImGui_Context ctx, optional integer auto_open_depthIn, optional string filenameIn)
(ImGui_Context ctx, Int auto_open_depthInOptional, String filenameInOptional) = ImGui_LogToFile(ctx, auto_open_depthInOptional, filenameInOptional)

Start logging all text output from the interface to a file.
The data is saved to $resource_path/imgui_log.txt if filename is nil.

void ImGui_LogToTTY(ImGui_Context* ctx, int* auto_open_depthInOptional)
ImGui_LogToTTY(ImGui_Context ctx, optional int auto_open_depthIn) (requires REAPER 6.24 or later)
extension_api("ImGui_LogToTTY", ImGui_Context ctx, optional int auto_open_depthIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_LogToTTY(ImGui_Context ctx, optional integer auto_open_depthIn)
(ImGui_Context ctx, Int auto_open_depthInOptional) = ImGui_LogToTTY(ctx, auto_open_depthInOptional)

Start logging all text output from the interface to the TTY (stdout).

bool ImGui_MenuItem(ImGui_Context* ctx, const char* label, const char* shortcutInOptional, bool* p_selectedInOutOptional, bool* enabledInOptional)
bool ImGui_MenuItem(ImGui_Context ctx, "label", optional "shortcutIn", optional bool &p_selected, optional bool enabledIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_MenuItem", ImGui_Context ctx, "label", optional "shortcutIn", optional bool &p_selected, optional bool enabledIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, optional boolean p_selected = reaper.ImGui_MenuItem(ImGui_Context ctx, string label, optional string shortcutIn, optional boolean p_selected, optional boolean enabledIn)
(Boolean retval, ImGui_Context ctx, String label, String shortcutInOptional, Boolean p_selectedInOutOptional, Boolean enabledInOptional) = ImGui_MenuItem(ctx, label, shortcutInOptional, p_selectedInOutOptional, enabledInOptional)

Return true when activated. Shortcuts are displayed for convenience but not
processed by ImGui at the moment. Toggle state is written to 'selected' when
provided.

int ImGui_Mod_Alt()
int ImGui_Mod_Alt() (requires REAPER 6.24 or later)
int extension_api("ImGui_Mod_Alt") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Mod_Alt()
Int ImGui_Mod_Alt()
int ImGui_Mod_Ctrl()
int ImGui_Mod_Ctrl() (requires REAPER 6.24 or later)
int extension_api("ImGui_Mod_Ctrl") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Mod_Ctrl()
Int ImGui_Mod_Ctrl()
int ImGui_Mod_None()
int ImGui_Mod_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_Mod_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Mod_None()
Int ImGui_Mod_None()
int ImGui_Mod_Shift()
int ImGui_Mod_Shift() (requires REAPER 6.24 or later)
int extension_api("ImGui_Mod_Shift") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Mod_Shift()
Int ImGui_Mod_Shift()
int ImGui_Mod_Shortcut()
int ImGui_Mod_Shortcut() (requires REAPER 6.24 or later)
int extension_api("ImGui_Mod_Shortcut") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Mod_Shortcut()
Int ImGui_Mod_Shortcut()

Alias for Mod_Ctrl on Linux and Windows and Mod_Super on macOS (Cmd key).

int ImGui_Mod_Super()
int ImGui_Mod_Super() (requires REAPER 6.24 or later)
int extension_api("ImGui_Mod_Super") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_Mod_Super()
Int ImGui_Mod_Super()
int ImGui_MouseButton_Left()
int ImGui_MouseButton_Left() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseButton_Left") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseButton_Left()
Int ImGui_MouseButton_Left()
int ImGui_MouseButton_Middle()
int ImGui_MouseButton_Middle() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseButton_Middle") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseButton_Middle()
Int ImGui_MouseButton_Middle()
int ImGui_MouseButton_Right()
int ImGui_MouseButton_Right() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseButton_Right") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseButton_Right()
Int ImGui_MouseButton_Right()
int ImGui_MouseCursor_Arrow()
int ImGui_MouseCursor_Arrow() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_Arrow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_Arrow()
Int ImGui_MouseCursor_Arrow()
int ImGui_MouseCursor_Hand()
int ImGui_MouseCursor_Hand() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_Hand") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_Hand()
Int ImGui_MouseCursor_Hand()

(Unused by Dear ImGui functions. Use for e.g. hyperlinks)

int ImGui_MouseCursor_None()
int ImGui_MouseCursor_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_None()
Int ImGui_MouseCursor_None()
int ImGui_MouseCursor_NotAllowed()
int ImGui_MouseCursor_NotAllowed() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_NotAllowed") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_NotAllowed()
Int ImGui_MouseCursor_NotAllowed()

When hovering something with disallowed interaction. Usually a crossed circle.

int ImGui_MouseCursor_ResizeAll()
int ImGui_MouseCursor_ResizeAll() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_ResizeAll") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_ResizeAll()
Int ImGui_MouseCursor_ResizeAll()

(Unused by Dear ImGui functions)

int ImGui_MouseCursor_ResizeEW()
int ImGui_MouseCursor_ResizeEW() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_ResizeEW") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_ResizeEW()
Int ImGui_MouseCursor_ResizeEW()

When hovering over a vertical border or a column.

int ImGui_MouseCursor_ResizeNESW()
int ImGui_MouseCursor_ResizeNESW() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_ResizeNESW") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_ResizeNESW()
Int ImGui_MouseCursor_ResizeNESW()

When hovering over the bottom-left corner of a window.

int ImGui_MouseCursor_ResizeNS()
int ImGui_MouseCursor_ResizeNS() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_ResizeNS") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_ResizeNS()
Int ImGui_MouseCursor_ResizeNS()

When hovering over a horizontal border.

int ImGui_MouseCursor_ResizeNWSE()
int ImGui_MouseCursor_ResizeNWSE() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_ResizeNWSE") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_ResizeNWSE()
Int ImGui_MouseCursor_ResizeNWSE()

When hovering over the bottom-right corner of a window.

int ImGui_MouseCursor_TextInput()
int ImGui_MouseCursor_TextInput() (requires REAPER 6.24 or later)
int extension_api("ImGui_MouseCursor_TextInput") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_MouseCursor_TextInput()
Int ImGui_MouseCursor_TextInput()

When hovering over InputText, etc.

void ImGui_NewLine(ImGui_Context* ctx)
ImGui_NewLine(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_NewLine", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_NewLine(ImGui_Context ctx)
ImGui_NewLine(ImGui_Context ctx)

Undo a SameLine() or force a new line when in a horizontal-layout context.

void ImGui_NumericLimits_Double(double* minOut, double* maxOut)
ImGui_NumericLimits_Double(&min, &max) (requires REAPER 6.24 or later)
extension_api("ImGui_NumericLimits_Double", &min, &max) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number min, number max = reaper.ImGui_NumericLimits_Double()
(Float minOut, Float maxOut) = ImGui_NumericLimits_Double(minOut, maxOut)

Returns DBL_MIN and DBL_MAX for this system.

void ImGui_NumericLimits_Float(double* minOut, double* maxOut)
ImGui_NumericLimits_Float(&min, &max) (requires REAPER 6.24 or later)
extension_api("ImGui_NumericLimits_Float", &min, &max) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number min, number max = reaper.ImGui_NumericLimits_Float()
(Float minOut, Float maxOut) = ImGui_NumericLimits_Float(minOut, maxOut)

Returns FLT_MIN and FLT_MAX for this system.

void ImGui_NumericLimits_Int(int* minOut, int* maxOut)
ImGui_NumericLimits_Int(int &min, int &max) (requires REAPER 6.24 or later)
extension_api("ImGui_NumericLimits_Int", int &min, int &max) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer min, integer max = reaper.ImGui_NumericLimits_Int()
(Int minOut, Int maxOut) = ImGui_NumericLimits_Int(minOut, maxOut)

Returns INT_MIN and INT_MAX for this system.

void ImGui_OpenPopup(ImGui_Context* ctx, const char* str_id, int* popup_flagsInOptional)
ImGui_OpenPopup(ImGui_Context ctx, "str_id", optional int popup_flagsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_OpenPopup", ImGui_Context ctx, "str_id", optional int popup_flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_OpenPopup(ImGui_Context ctx, string str_id, optional integer popup_flagsIn)
(ImGui_Context ctx, String str_id, Int popup_flagsInOptional) = ImGui_OpenPopup(ctx, str_id, popup_flagsInOptional)

Set popup state to open (don't call every frame!).
ImGuiPopupFlags are available for opening options.

If not modal: they can be closed by clicking anywhere outside them, or by
pressing ESCAPE.

Use PopupFlags_NoOpenOverExistingPopup to avoid opening a popup if there's
already one at the same level.

void ImGui_OpenPopupOnItemClick(ImGui_Context* ctx, const char* str_idInOptional, int* popup_flagsInOptional)
ImGui_OpenPopupOnItemClick(ImGui_Context ctx, optional "str_idIn", optional int popup_flagsIn) (requires REAPER 6.24 or later)
extension_api("ImGui_OpenPopupOnItemClick", ImGui_Context ctx, optional "str_idIn", optional int popup_flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_OpenPopupOnItemClick(ImGui_Context ctx, optional string str_idIn, optional integer popup_flagsIn)
(ImGui_Context ctx, String str_idInOptional, Int popup_flagsInOptional) = ImGui_OpenPopupOnItemClick(ctx, str_idInOptional, popup_flagsInOptional)

Helper to open popup when clicked on last item. return true when just opened.
(Note: actually triggers on the mouse _released_ event to be consistent with
popup behaviors.)

void ImGui_PlotHistogram(ImGui_Context* ctx, const char* label, reaper_array* values, int* values_offsetInOptional, const char* overlay_textInOptional, double* scale_minInOptional, double* scale_maxInOptional, double* graph_size_wInOptional, double* graph_size_hInOptional)
ImGui_PlotHistogram(ImGui_Context ctx, "label", reaper_array values, optional int values_offsetIn, optional "overlay_textIn", optional scale_minIn, optional scale_maxIn, optional graph_size_wIn, optional graph_size_hIn) (requires REAPER 6.24 or later)
extension_api("ImGui_PlotHistogram", ImGui_Context ctx, "label", reaper_array values, optional int values_offsetIn, optional "overlay_textIn", optional scale_minIn, optional scale_maxIn, optional graph_size_wIn, optional graph_size_hIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PlotHistogram(ImGui_Context ctx, string label, reaper_array values, optional integer values_offsetIn, optional string overlay_textIn, optional number scale_minIn, optional number scale_maxIn, optional number graph_size_wIn, optional number graph_size_hIn)
(ImGui_Context ctx, String label, reaper_array values, Int values_offsetInOptional, String overlay_textInOptional, Float scale_minInOptional, Float scale_maxInOptional, Float graph_size_wInOptional, Float graph_size_hInOptional) = ImGui_PlotHistogram(ctx, label, values, values_offsetInOptional, overlay_textInOptional, scale_minInOptional, scale_maxInOptional, graph_size_wInOptional, graph_size_hInOptional)
void ImGui_PlotLines(ImGui_Context* ctx, const char* label, reaper_array* values, int* values_offsetInOptional, const char* overlay_textInOptional, double* scale_minInOptional, double* scale_maxInOptional, double* graph_size_wInOptional, double* graph_size_hInOptional)
ImGui_PlotLines(ImGui_Context ctx, "label", reaper_array values, optional int values_offsetIn, optional "overlay_textIn", optional scale_minIn, optional scale_maxIn, optional graph_size_wIn, optional graph_size_hIn) (requires REAPER 6.24 or later)
extension_api("ImGui_PlotLines", ImGui_Context ctx, "label", reaper_array values, optional int values_offsetIn, optional "overlay_textIn", optional scale_minIn, optional scale_maxIn, optional graph_size_wIn, optional graph_size_hIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PlotLines(ImGui_Context ctx, string label, reaper_array values, optional integer values_offsetIn, optional string overlay_textIn, optional number scale_minIn, optional number scale_maxIn, optional number graph_size_wIn, optional number graph_size_hIn)
(ImGui_Context ctx, String label, reaper_array values, Int values_offsetInOptional, String overlay_textInOptional, Float scale_minInOptional, Float scale_maxInOptional, Float graph_size_wInOptional, Float graph_size_hInOptional) = ImGui_PlotLines(ctx, label, values, values_offsetInOptional, overlay_textInOptional, scale_minInOptional, scale_maxInOptional, graph_size_wInOptional, graph_size_hInOptional)
void ImGui_PointConvertNative(ImGui_Context* ctx, double* xInOut, double* yInOut, bool* to_nativeInOptional)
ImGui_PointConvertNative(ImGui_Context ctx, &x, &y, optional bool to_nativeIn) (requires REAPER 6.24 or later)
extension_api("ImGui_PointConvertNative", ImGui_Context ctx, &x, &y, optional bool to_nativeIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_PointConvertNative(ImGui_Context ctx, number x, number y, optional boolean to_nativeIn)
(ImGui_Context ctx, Float xInOut, Float yInOut, Boolean to_nativeInOptional) = ImGui_PointConvertNative(ctx, xInOut, yInOut, to_nativeInOptional)

Convert a position from the current platform's native coordinate position
system to ReaImGui global coordinates (or vice versa).

This effectively flips the Y coordinate on macOS and applies HiDPI scaling on
Windows and Linux.

void ImGui_PopButtonRepeat(ImGui_Context* ctx)
ImGui_PopButtonRepeat(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_PopButtonRepeat", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PopButtonRepeat(ImGui_Context ctx)
ImGui_PopButtonRepeat(ImGui_Context ctx)

See PushButtonRepeat

void ImGui_PopClipRect(ImGui_Context* ctx)
ImGui_PopClipRect(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_PopClipRect", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PopClipRect(ImGui_Context ctx)
ImGui_PopClipRect(ImGui_Context ctx)

See PushClipRect

void ImGui_PopFont(ImGui_Context* ctx)
ImGui_PopFont(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_PopFont", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PopFont(ImGui_Context ctx)
ImGui_PopFont(ImGui_Context ctx)

See PushFont.

void ImGui_PopID(ImGui_Context* ctx)
ImGui_PopID(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_PopID", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PopID(ImGui_Context ctx)
ImGui_PopID(ImGui_Context ctx)

Pop from the ID stack.

void ImGui_PopItemWidth(ImGui_Context* ctx)
ImGui_PopItemWidth(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_PopItemWidth", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PopItemWidth(ImGui_Context ctx)
ImGui_PopItemWidth(ImGui_Context ctx)

See PushItemWidth

void ImGui_PopStyleColor(ImGui_Context* ctx, int* countInOptional)
ImGui_PopStyleColor(ImGui_Context ctx, optional int countIn) (requires REAPER 6.24 or later)
extension_api("ImGui_PopStyleColor", ImGui_Context ctx, optional int countIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PopStyleColor(ImGui_Context ctx, optional integer countIn)
(ImGui_Context ctx, Int countInOptional) = ImGui_PopStyleColor(ctx, countInOptional)
void ImGui_PopStyleVar(ImGui_Context* ctx, int* countInOptional)
ImGui_PopStyleVar(ImGui_Context ctx, optional int countIn) (requires REAPER 6.24 or later)
extension_api("ImGui_PopStyleVar", ImGui_Context ctx, optional int countIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PopStyleVar(ImGui_Context ctx, optional integer countIn)
(ImGui_Context ctx, Int countInOptional) = ImGui_PopStyleVar(ctx, countInOptional)

Reset a style variable.

void ImGui_PopTabStop(ImGui_Context* ctx)
ImGui_PopTabStop(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_PopTabStop", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PopTabStop(ImGui_Context ctx)
ImGui_PopTabStop(ImGui_Context ctx)

See PushTabStop

void ImGui_PopTextWrapPos(ImGui_Context* ctx)
ImGui_PopTextWrapPos(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_PopTextWrapPos", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PopTextWrapPos(ImGui_Context ctx)
ImGui_PopTextWrapPos(ImGui_Context ctx)
int ImGui_PopupFlags_AnyPopup()
int ImGui_PopupFlags_AnyPopup() (requires REAPER 6.24 or later)
int extension_api("ImGui_PopupFlags_AnyPopup") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_PopupFlags_AnyPopup()
Int ImGui_PopupFlags_AnyPopup()

PopupFlags_AnyPopupId | PopupFlags_AnyPopupLevel

int ImGui_PopupFlags_AnyPopupId()
int ImGui_PopupFlags_AnyPopupId() (requires REAPER 6.24 or later)
int extension_api("ImGui_PopupFlags_AnyPopupId") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_PopupFlags_AnyPopupId()
Int ImGui_PopupFlags_AnyPopupId()

For IsPopupOpen: ignore the str_id parameter and test for any popup.

int ImGui_PopupFlags_AnyPopupLevel()
int ImGui_PopupFlags_AnyPopupLevel() (requires REAPER 6.24 or later)
int extension_api("ImGui_PopupFlags_AnyPopupLevel") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_PopupFlags_AnyPopupLevel()
Int ImGui_PopupFlags_AnyPopupLevel()

For IsPopupOpen: search/test at any level of the popup stack
(default test in the current level).

int ImGui_PopupFlags_MouseButtonLeft()
int ImGui_PopupFlags_MouseButtonLeft() (requires REAPER 6.24 or later)
int extension_api("ImGui_PopupFlags_MouseButtonLeft") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_PopupFlags_MouseButtonLeft()
Int ImGui_PopupFlags_MouseButtonLeft()

For BeginPopupContext*(): open on Left Mouse release.
Guaranteed to always be == 0 (same as MouseButton_Left).

int ImGui_PopupFlags_MouseButtonMiddle()
int ImGui_PopupFlags_MouseButtonMiddle() (requires REAPER 6.24 or later)
int extension_api("ImGui_PopupFlags_MouseButtonMiddle") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_PopupFlags_MouseButtonMiddle()
Int ImGui_PopupFlags_MouseButtonMiddle()

For BeginPopupContext*(): open on Middle Mouse release.
Guaranteed to always be == 2 (same as MouseButton_Middle).

int ImGui_PopupFlags_MouseButtonRight()
int ImGui_PopupFlags_MouseButtonRight() (requires REAPER 6.24 or later)
int extension_api("ImGui_PopupFlags_MouseButtonRight") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_PopupFlags_MouseButtonRight()
Int ImGui_PopupFlags_MouseButtonRight()

For BeginPopupContext*(): open on Right Mouse release.
Guaranteed to always be == 1 (same as MouseButton_Right).

int ImGui_PopupFlags_NoOpenOverExistingPopup()
int ImGui_PopupFlags_NoOpenOverExistingPopup() (requires REAPER 6.24 or later)
int extension_api("ImGui_PopupFlags_NoOpenOverExistingPopup") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_PopupFlags_NoOpenOverExistingPopup()
Int ImGui_PopupFlags_NoOpenOverExistingPopup()

For OpenPopup*(), BeginPopupContext*(): don't open if there's already a popup
at the same level of the popup stack.

int ImGui_PopupFlags_NoOpenOverItems()
int ImGui_PopupFlags_NoOpenOverItems() (requires REAPER 6.24 or later)
int extension_api("ImGui_PopupFlags_NoOpenOverItems") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_PopupFlags_NoOpenOverItems()
Int ImGui_PopupFlags_NoOpenOverItems()

For BeginPopupContextWindow: don't return true when hovering items,
only when hovering empty space.

int ImGui_PopupFlags_None()
int ImGui_PopupFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_PopupFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_PopupFlags_None()
Int ImGui_PopupFlags_None()
void ImGui_ProgressBar(ImGui_Context* ctx, double fraction, double* size_arg_wInOptional, double* size_arg_hInOptional, const char* overlayInOptional)
ImGui_ProgressBar(ImGui_Context ctx, fraction, optional size_arg_wIn, optional size_arg_hIn, optional "overlayIn") (requires REAPER 6.24 or later)
extension_api("ImGui_ProgressBar", ImGui_Context ctx, fraction, optional size_arg_wIn, optional size_arg_hIn, optional "overlayIn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_ProgressBar(ImGui_Context ctx, number fraction, optional number size_arg_wIn, optional number size_arg_hIn, optional string overlayIn)
(ImGui_Context ctx, Float fraction, Float size_arg_wInOptional, Float size_arg_hInOptional, String overlayInOptional) = ImGui_ProgressBar(ctx, fraction, size_arg_wInOptional, size_arg_hInOptional, overlayInOptional)
void ImGui_PushButtonRepeat(ImGui_Context* ctx, bool repeat)
ImGui_PushButtonRepeat(ImGui_Context ctx, bool repeat) (requires REAPER 6.24 or later)
extension_api("ImGui_PushButtonRepeat", ImGui_Context ctx, bool repeat) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PushButtonRepeat(ImGui_Context ctx, boolean repeat)
ImGui_PushButtonRepeat(ImGui_Context ctx, Boolean repeat)

In 'repeat' mode, Button*() functions return repeated true in a typematic
manner (using ConfigVar_KeyRepeatDelay/ConfigVar_KeyRepeatRate settings).

Note that you can call IsItemActive after any Button to tell if the button is
held in the current frame.

void ImGui_PushClipRect(ImGui_Context* ctx, double clip_rect_min_x, double clip_rect_min_y, double clip_rect_max_x, double clip_rect_max_y, bool intersect_with_current_clip_rect)
ImGui_PushClipRect(ImGui_Context ctx, clip_rect_min_x, clip_rect_min_y, clip_rect_max_x, clip_rect_max_y, bool intersect_with_current_clip_rect) (requires REAPER 6.24 or later)
extension_api("ImGui_PushClipRect", ImGui_Context ctx, clip_rect_min_x, clip_rect_min_y, clip_rect_max_x, clip_rect_max_y, bool intersect_with_current_clip_rect) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PushClipRect(ImGui_Context ctx, number clip_rect_min_x, number clip_rect_min_y, number clip_rect_max_x, number clip_rect_max_y, boolean intersect_with_current_clip_rect)
ImGui_PushClipRect(ImGui_Context ctx, Float clip_rect_min_x, Float clip_rect_min_y, Float clip_rect_max_x, Float clip_rect_max_y, Boolean intersect_with_current_clip_rect)
void ImGui_PushFont(ImGui_Context* ctx, ImGui_Font* font)
ImGui_PushFont(ImGui_Context ctx, ImGui_Font font) (requires REAPER 6.24 or later)
extension_api("ImGui_PushFont", ImGui_Context ctx, ImGui_Font font) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PushFont(ImGui_Context ctx, ImGui_Font font)
ImGui_PushFont(ImGui_Context ctx, ImGui_Font font)

Change the current font. Use nil to push the default font.
The font object must have been registered using Attach. See PopFont.

void ImGui_PushID(ImGui_Context* ctx, const char* str_id)
ImGui_PushID(ImGui_Context ctx, "str_id") (requires REAPER 6.24 or later)
extension_api("ImGui_PushID", ImGui_Context ctx, "str_id") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PushID(ImGui_Context ctx, string str_id)
ImGui_PushID(ImGui_Context ctx, String str_id)

Push string into the ID stack.

void ImGui_PushItemWidth(ImGui_Context* ctx, double item_width)
ImGui_PushItemWidth(ImGui_Context ctx, item_width) (requires REAPER 6.24 or later)
extension_api("ImGui_PushItemWidth", ImGui_Context ctx, item_width) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PushItemWidth(ImGui_Context ctx, number item_width)
ImGui_PushItemWidth(ImGui_Context ctx, Float item_width)

Push width of items for common large "item+label" widgets.

- \>0.0: width in pixels
- <0.0 align xx pixels to the right of window
(so -FLT_MIN always align width to the right side)
- 0.0 = default to ~2/3 of windows width.

void ImGui_PushStyleColor(ImGui_Context* ctx, int idx, int col_rgba)
ImGui_PushStyleColor(ImGui_Context ctx, int idx, int col_rgba) (requires REAPER 6.24 or later)
extension_api("ImGui_PushStyleColor", ImGui_Context ctx, int idx, int col_rgba) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PushStyleColor(ImGui_Context ctx, integer idx, integer col_rgba)
ImGui_PushStyleColor(ImGui_Context ctx, Int idx, Int col_rgba)

Temporarily modify a style color.
Call PopStyleColor to undo after use (before the end of the frame).
See Col_* for available style colors.

void ImGui_PushStyleVar(ImGui_Context* ctx, int var_idx, double val1, double* val2InOptional)
ImGui_PushStyleVar(ImGui_Context ctx, int var_idx, val1, optional val2In) (requires REAPER 6.24 or later)
extension_api("ImGui_PushStyleVar", ImGui_Context ctx, int var_idx, val1, optional val2In) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PushStyleVar(ImGui_Context ctx, integer var_idx, number val1, optional number val2In)
(ImGui_Context ctx, Int var_idx, Float val1, Float val2InOptional) = ImGui_PushStyleVar(ctx, var_idx, val1, val2InOptional)

Temporarily modify a style variable.
Call PopStyleVar to undo after use (before the end of the frame).
See StyleVar_* for possible values of 'var_idx'.

void ImGui_PushTabStop(ImGui_Context* ctx, bool tab_stop)
ImGui_PushTabStop(ImGui_Context ctx, bool tab_stop) (requires REAPER 6.24 or later)
extension_api("ImGui_PushTabStop", ImGui_Context ctx, bool tab_stop) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PushTabStop(ImGui_Context ctx, boolean tab_stop)
ImGui_PushTabStop(ImGui_Context ctx, Boolean tab_stop)

Allow focusing using TAB/Shift-TAB, enabled by default but you can disable it
for certain widgets

void ImGui_PushTextWrapPos(ImGui_Context* ctx, double* wrap_local_pos_xInOptional)
ImGui_PushTextWrapPos(ImGui_Context ctx, optional wrap_local_pos_xIn) (requires REAPER 6.24 or later)
extension_api("ImGui_PushTextWrapPos", ImGui_Context ctx, optional wrap_local_pos_xIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_PushTextWrapPos(ImGui_Context ctx, optional number wrap_local_pos_xIn)
(ImGui_Context ctx, Float wrap_local_pos_xInOptional) = ImGui_PushTextWrapPos(ctx, wrap_local_pos_xInOptional)

Push word-wrapping position for Text*() commands.

- < 0.0: no wrapping
- = 0.0: wrap to end of window (or column)
- \> 0.0: wrap at 'wrap_pos_x' position in window local space.

bool ImGui_RadioButton(ImGui_Context* ctx, const char* label, bool active)
bool ImGui_RadioButton(ImGui_Context ctx, "label", bool active) (requires REAPER 6.24 or later)
bool extension_api("ImGui_RadioButton", ImGui_Context ctx, "label", bool active) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_RadioButton(ImGui_Context ctx, string label, boolean active)
Boolean ImGui_RadioButton(ImGui_Context ctx, String label, Boolean active)

Use with e.g. if (RadioButton("one", my_value==1)) { my_value = 1; }

bool ImGui_RadioButtonEx(ImGui_Context* ctx, const char* label, int* vInOut, int v_button)
bool ImGui_RadioButtonEx(ImGui_Context ctx, "label", int &v, int v_button) (requires REAPER 6.24 or later)
bool extension_api("ImGui_RadioButtonEx", ImGui_Context ctx, "label", int &v, int v_button) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v = reaper.ImGui_RadioButtonEx(ImGui_Context ctx, string label, integer v, integer v_button)
(Boolean retval, ImGui_Context ctx, String label, Int vInOut, Int v_button) = ImGui_RadioButtonEx(ctx, label, vInOut, v_button)

Shortcut to handle RadioButton's example pattern when value is an integer

void ImGui_ResetMouseDragDelta(ImGui_Context* ctx, int* buttonInOptional)
ImGui_ResetMouseDragDelta(ImGui_Context ctx, optional int buttonIn) (requires REAPER 6.24 or later)
extension_api("ImGui_ResetMouseDragDelta", ImGui_Context ctx, optional int buttonIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_ResetMouseDragDelta(ImGui_Context ctx, optional integer buttonIn)
(ImGui_Context ctx, Int buttonInOptional) = ImGui_ResetMouseDragDelta(ctx, buttonInOptional)
void ImGui_SameLine(ImGui_Context* ctx, double* offset_from_start_xInOptional, double* spacingInOptional)
ImGui_SameLine(ImGui_Context ctx, optional offset_from_start_xIn, optional spacingIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SameLine", ImGui_Context ctx, optional offset_from_start_xIn, optional spacingIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SameLine(ImGui_Context ctx, optional number offset_from_start_xIn, optional number spacingIn)
(ImGui_Context ctx, Float offset_from_start_xInOptional, Float spacingInOptional) = ImGui_SameLine(ctx, offset_from_start_xInOptional, spacingInOptional)

Call between widgets or groups to layout them horizontally.
X position given in window coordinates.

bool ImGui_Selectable(ImGui_Context* ctx, const char* label, bool* p_selectedInOut, int* flagsInOptional, double* size_wInOptional, double* size_hInOptional)
bool ImGui_Selectable(ImGui_Context ctx, "label", bool &p_selected, optional int flagsIn, optional size_wIn, optional size_hIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_Selectable", ImGui_Context ctx, "label", bool &p_selected, optional int flagsIn, optional size_wIn, optional size_hIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, boolean p_selected = reaper.ImGui_Selectable(ImGui_Context ctx, string label, boolean p_selected, optional integer flagsIn, optional number size_wIn, optional number size_hIn)
(Boolean retval, ImGui_Context ctx, String label, Boolean p_selectedInOut, Int flagsInOptional, Float size_wInOptional, Float size_hInOptional) = ImGui_Selectable(ctx, label, p_selectedInOut, flagsInOptional, size_wInOptional, size_hInOptional)
int ImGui_SelectableFlags_AllowDoubleClick()
int ImGui_SelectableFlags_AllowDoubleClick() (requires REAPER 6.24 or later)
int extension_api("ImGui_SelectableFlags_AllowDoubleClick") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SelectableFlags_AllowDoubleClick()
Int ImGui_SelectableFlags_AllowDoubleClick()

Generate press events on double clicks too.

int ImGui_SelectableFlags_AllowItemOverlap()
int ImGui_SelectableFlags_AllowItemOverlap() (requires REAPER 6.24 or later)
int extension_api("ImGui_SelectableFlags_AllowItemOverlap") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SelectableFlags_AllowItemOverlap()
Int ImGui_SelectableFlags_AllowItemOverlap()

Hit testing to allow subsequent widgets to overlap this one.

int ImGui_SelectableFlags_Disabled()
int ImGui_SelectableFlags_Disabled() (requires REAPER 6.24 or later)
int extension_api("ImGui_SelectableFlags_Disabled") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SelectableFlags_Disabled()
Int ImGui_SelectableFlags_Disabled()

Cannot be selected, display grayed out text.

int ImGui_SelectableFlags_DontClosePopups()
int ImGui_SelectableFlags_DontClosePopups() (requires REAPER 6.24 or later)
int extension_api("ImGui_SelectableFlags_DontClosePopups") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SelectableFlags_DontClosePopups()
Int ImGui_SelectableFlags_DontClosePopups()

Clicking this doesn't close parent popup window.

int ImGui_SelectableFlags_None()
int ImGui_SelectableFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_SelectableFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SelectableFlags_None()
Int ImGui_SelectableFlags_None()
int ImGui_SelectableFlags_SpanAllColumns()
int ImGui_SelectableFlags_SpanAllColumns() (requires REAPER 6.24 or later)
int extension_api("ImGui_SelectableFlags_SpanAllColumns") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SelectableFlags_SpanAllColumns()
Int ImGui_SelectableFlags_SpanAllColumns()

Selectable frame can span all columns (text will still fit in current column).

void ImGui_Separator(ImGui_Context* ctx)
ImGui_Separator(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_Separator", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Separator(ImGui_Context ctx)
ImGui_Separator(ImGui_Context ctx)

Separator, generally horizontal. inside a menu bar or in horizontal layout
mode, this becomes a vertical separator.

void ImGui_SeparatorText(ImGui_Context* ctx, const char* label)
ImGui_SeparatorText(ImGui_Context ctx, "label") (requires REAPER 6.24 or later)
extension_api("ImGui_SeparatorText", ImGui_Context ctx, "label") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SeparatorText(ImGui_Context ctx, string label)
ImGui_SeparatorText(ImGui_Context ctx, String label)

Text formatted with an horizontal line

void ImGui_SetClipboardText(ImGui_Context* ctx, const char* text)
ImGui_SetClipboardText(ImGui_Context ctx, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_SetClipboardText", ImGui_Context ctx, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetClipboardText(ImGui_Context ctx, string text)
ImGui_SetClipboardText(ImGui_Context ctx, String text)

See also the LogToClipboard function to capture GUI into clipboard,
or easily output text data to the clipboard.

void ImGui_SetColorEditOptions(ImGui_Context* ctx, int flags)
ImGui_SetColorEditOptions(ImGui_Context ctx, int flags) (requires REAPER 6.24 or later)
extension_api("ImGui_SetColorEditOptions", ImGui_Context ctx, int flags) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetColorEditOptions(ImGui_Context ctx, integer flags)
ImGui_SetColorEditOptions(ImGui_Context ctx, Int flags)

Picker type, etc. User will be able to change many settings, unless you pass
the _NoOptions flag to your calls.

void ImGui_SetConfigVar(ImGui_Context* ctx, int var_idx, double value)
ImGui_SetConfigVar(ImGui_Context ctx, int var_idx, value) (requires REAPER 6.24 or later)
extension_api("ImGui_SetConfigVar", ImGui_Context ctx, int var_idx, value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetConfigVar(ImGui_Context ctx, integer var_idx, number value)
ImGui_SetConfigVar(ImGui_Context ctx, Int var_idx, Float value)
void ImGui_SetCursorPos(ImGui_Context* ctx, double local_pos_x, double local_pos_y)
ImGui_SetCursorPos(ImGui_Context ctx, local_pos_x, local_pos_y) (requires REAPER 6.24 or later)
extension_api("ImGui_SetCursorPos", ImGui_Context ctx, local_pos_x, local_pos_y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetCursorPos(ImGui_Context ctx, number local_pos_x, number local_pos_y)
ImGui_SetCursorPos(ImGui_Context ctx, Float local_pos_x, Float local_pos_y)

Cursor position in window

void ImGui_SetCursorPosX(ImGui_Context* ctx, double local_x)
ImGui_SetCursorPosX(ImGui_Context ctx, local_x) (requires REAPER 6.24 or later)
extension_api("ImGui_SetCursorPosX", ImGui_Context ctx, local_x) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetCursorPosX(ImGui_Context ctx, number local_x)
ImGui_SetCursorPosX(ImGui_Context ctx, Float local_x)

Cursor X position in window

void ImGui_SetCursorPosY(ImGui_Context* ctx, double local_y)
ImGui_SetCursorPosY(ImGui_Context ctx, local_y) (requires REAPER 6.24 or later)
extension_api("ImGui_SetCursorPosY", ImGui_Context ctx, local_y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetCursorPosY(ImGui_Context ctx, number local_y)
ImGui_SetCursorPosY(ImGui_Context ctx, Float local_y)

Cursor Y position in window

void ImGui_SetCursorScreenPos(ImGui_Context* ctx, double pos_x, double pos_y)
ImGui_SetCursorScreenPos(ImGui_Context ctx, pos_x, pos_y) (requires REAPER 6.24 or later)
extension_api("ImGui_SetCursorScreenPos", ImGui_Context ctx, pos_x, pos_y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetCursorScreenPos(ImGui_Context ctx, number pos_x, number pos_y)
ImGui_SetCursorScreenPos(ImGui_Context ctx, Float pos_x, Float pos_y)

Cursor position in absolute screen coordinates.

bool ImGui_SetDragDropPayload(ImGui_Context* ctx, const char* type, const char* data, int* condInOptional)
bool ImGui_SetDragDropPayload(ImGui_Context ctx, "type", "data", optional int condIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SetDragDropPayload", ImGui_Context ctx, "type", "data", optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_SetDragDropPayload(ImGui_Context ctx, string type, string data, optional integer condIn)
(Boolean retval, ImGui_Context ctx, String type, String data, Int condInOptional) = ImGui_SetDragDropPayload(ctx, type, data, condInOptional)

The type is a user defined string of maximum 32 characters.
Strings starting with '_' are reserved for dear imgui internal types.
Data is copied and held by imgui.

void ImGui_SetItemAllowOverlap(ImGui_Context* ctx)
ImGui_SetItemAllowOverlap(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_SetItemAllowOverlap", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetItemAllowOverlap(ImGui_Context ctx)
ImGui_SetItemAllowOverlap(ImGui_Context ctx)

Allow last item to be overlapped by a subsequent item. sometimes useful with
invisible buttons, selectables, etc. to catch unused area.

void ImGui_SetItemDefaultFocus(ImGui_Context* ctx)
ImGui_SetItemDefaultFocus(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_SetItemDefaultFocus", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetItemDefaultFocus(ImGui_Context ctx)
ImGui_SetItemDefaultFocus(ImGui_Context ctx)

Make last item the default focused item of a window.

void ImGui_SetKeyboardFocusHere(ImGui_Context* ctx, int* offsetInOptional)
ImGui_SetKeyboardFocusHere(ImGui_Context ctx, optional int offsetIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetKeyboardFocusHere", ImGui_Context ctx, optional int offsetIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetKeyboardFocusHere(ImGui_Context ctx, optional integer offsetIn)
(ImGui_Context ctx, Int offsetInOptional) = ImGui_SetKeyboardFocusHere(ctx, offsetInOptional)

Focus keyboard on the next widget. Use positive 'offset' to access sub
components of a multiple component widget. Use -1 to access previous widget.

void ImGui_SetMouseCursor(ImGui_Context* ctx, int cursor_type)
ImGui_SetMouseCursor(ImGui_Context ctx, int cursor_type) (requires REAPER 6.24 or later)
extension_api("ImGui_SetMouseCursor", ImGui_Context ctx, int cursor_type) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetMouseCursor(ImGui_Context ctx, integer cursor_type)
ImGui_SetMouseCursor(ImGui_Context ctx, Int cursor_type)

Set desired mouse cursor shape. See MouseCursor_* for possible values.

void ImGui_SetNextFrameWantCaptureKeyboard(ImGui_Context* ctx, bool want_capture_keyboard)
ImGui_SetNextFrameWantCaptureKeyboard(ImGui_Context ctx, bool want_capture_keyboard) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextFrameWantCaptureKeyboard", ImGui_Context ctx, bool want_capture_keyboard) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextFrameWantCaptureKeyboard(ImGui_Context ctx, boolean want_capture_keyboard)
ImGui_SetNextFrameWantCaptureKeyboard(ImGui_Context ctx, Boolean want_capture_keyboard)

Request capture of keyboard shortcuts in REAPER's global scope for the next frame.

void ImGui_SetNextItemOpen(ImGui_Context* ctx, bool is_open, int* condInOptional)
ImGui_SetNextItemOpen(ImGui_Context ctx, bool is_open, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextItemOpen", ImGui_Context ctx, bool is_open, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextItemOpen(ImGui_Context ctx, boolean is_open, optional integer condIn)
(ImGui_Context ctx, Boolean is_open, Int condInOptional) = ImGui_SetNextItemOpen(ctx, is_open, condInOptional)

Set next TreeNode/CollapsingHeader open state.
Can also be done with the TreeNodeFlags_DefaultOpen flag.

void ImGui_SetNextItemWidth(ImGui_Context* ctx, double item_width)
ImGui_SetNextItemWidth(ImGui_Context ctx, item_width) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextItemWidth", ImGui_Context ctx, item_width) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextItemWidth(ImGui_Context ctx, number item_width)
ImGui_SetNextItemWidth(ImGui_Context ctx, Float item_width)

Set width of the _next_ common large "item+label" widget.

- \>0.0: width in pixels
- <0.0 align xx pixels to the right of window
(so -FLT_MIN always align width to the right side)

void ImGui_SetNextWindowBgAlpha(ImGui_Context* ctx, double alpha)
ImGui_SetNextWindowBgAlpha(ImGui_Context ctx, alpha) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextWindowBgAlpha", ImGui_Context ctx, alpha) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextWindowBgAlpha(ImGui_Context ctx, number alpha)
ImGui_SetNextWindowBgAlpha(ImGui_Context ctx, Float alpha)

Set next window background color alpha. Helper to easily override the Alpha
component of Col_WindowBg/Col_ChildBg/Col_PopupBg.
You may also use WindowFlags_NoBackground for a fully transparent window.

void ImGui_SetNextWindowCollapsed(ImGui_Context* ctx, bool collapsed, int* condInOptional)
ImGui_SetNextWindowCollapsed(ImGui_Context ctx, bool collapsed, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextWindowCollapsed", ImGui_Context ctx, bool collapsed, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextWindowCollapsed(ImGui_Context ctx, boolean collapsed, optional integer condIn)
(ImGui_Context ctx, Boolean collapsed, Int condInOptional) = ImGui_SetNextWindowCollapsed(ctx, collapsed, condInOptional)

Set next window collapsed state.

void ImGui_SetNextWindowContentSize(ImGui_Context* ctx, double size_w, double size_h)
ImGui_SetNextWindowContentSize(ImGui_Context ctx, size_w, size_h) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextWindowContentSize", ImGui_Context ctx, size_w, size_h) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextWindowContentSize(ImGui_Context ctx, number size_w, number size_h)
ImGui_SetNextWindowContentSize(ImGui_Context ctx, Float size_w, Float size_h)

Set next window content size (~ scrollable client area, which enforce the
range of scrollbars). Not including window decorations (title bar, menu bar,
etc.) nor StyleVar_WindowPadding. set an axis to 0.0 to leave it automatic.

void ImGui_SetNextWindowDockID(ImGui_Context* ctx, int dock_id, int* condInOptional)
ImGui_SetNextWindowDockID(ImGui_Context ctx, int dock_id, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextWindowDockID", ImGui_Context ctx, int dock_id, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextWindowDockID(ImGui_Context ctx, integer dock_id, optional integer condIn)
(ImGui_Context ctx, Int dock_id, Int condInOptional) = ImGui_SetNextWindowDockID(ctx, dock_id, condInOptional)
void ImGui_SetNextWindowFocus(ImGui_Context* ctx)
ImGui_SetNextWindowFocus(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextWindowFocus", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextWindowFocus(ImGui_Context ctx)
ImGui_SetNextWindowFocus(ImGui_Context ctx)

Set next window to be focused / top-most.

void ImGui_SetNextWindowPos(ImGui_Context* ctx, double pos_x, double pos_y, int* condInOptional, double* pivot_xInOptional, double* pivot_yInOptional)
ImGui_SetNextWindowPos(ImGui_Context ctx, pos_x, pos_y, optional int condIn, optional pivot_xIn, optional pivot_yIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextWindowPos", ImGui_Context ctx, pos_x, pos_y, optional int condIn, optional pivot_xIn, optional pivot_yIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextWindowPos(ImGui_Context ctx, number pos_x, number pos_y, optional integer condIn, optional number pivot_xIn, optional number pivot_yIn)
(ImGui_Context ctx, Float pos_x, Float pos_y, Int condInOptional, Float pivot_xInOptional, Float pivot_yInOptional) = ImGui_SetNextWindowPos(ctx, pos_x, pos_y, condInOptional, pivot_xInOptional, pivot_yInOptional)

Set next window position. Use pivot=(0.5,0.5) to center on given point, etc.

void ImGui_SetNextWindowScroll(ImGui_Context* ctx, double scroll_x, double scroll_y)
ImGui_SetNextWindowScroll(ImGui_Context ctx, scroll_x, scroll_y) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextWindowScroll", ImGui_Context ctx, scroll_x, scroll_y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextWindowScroll(ImGui_Context ctx, number scroll_x, number scroll_y)
ImGui_SetNextWindowScroll(ImGui_Context ctx, Float scroll_x, Float scroll_y)

Set next window scrolling value (use < 0.0 to not affect a given axis).

void ImGui_SetNextWindowSize(ImGui_Context* ctx, double size_w, double size_h, int* condInOptional)
ImGui_SetNextWindowSize(ImGui_Context ctx, size_w, size_h, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextWindowSize", ImGui_Context ctx, size_w, size_h, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextWindowSize(ImGui_Context ctx, number size_w, number size_h, optional integer condIn)
(ImGui_Context ctx, Float size_w, Float size_h, Int condInOptional) = ImGui_SetNextWindowSize(ctx, size_w, size_h, condInOptional)

Set next window size. set axis to 0.0 to force an auto-fit on this axis.

void ImGui_SetNextWindowSizeConstraints(ImGui_Context* ctx, double size_min_w, double size_min_h, double size_max_w, double size_max_h, ImGui_Function* custom_callbackInOptional)
ImGui_SetNextWindowSizeConstraints(ImGui_Context ctx, size_min_w, size_min_h, size_max_w, size_max_h, ImGui_Function custom_callbackIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetNextWindowSizeConstraints", ImGui_Context ctx, size_min_w, size_min_h, size_max_w, size_max_h, ImGui_Function custom_callbackIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetNextWindowSizeConstraints(ImGui_Context ctx, number size_min_w, number size_min_h, number size_max_w, number size_max_h, ImGui_Function custom_callbackIn)
ImGui_SetNextWindowSizeConstraints(ImGui_Context ctx, Float size_min_w, Float size_min_h, Float size_max_w, Float size_max_h, ImGui_Function custom_callbackInOptional)

Set next window size limits. Use -1,-1 on either X/Y axis to preserve the
current size. Use FLT_MAX (second return value of NumericLimits_Float) for no
maximum size. Sizes will be rounded down.

void ImGui_SetScrollFromPosX(ImGui_Context* ctx, double local_x, double* center_x_ratioInOptional)
ImGui_SetScrollFromPosX(ImGui_Context ctx, local_x, optional center_x_ratioIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetScrollFromPosX", ImGui_Context ctx, local_x, optional center_x_ratioIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetScrollFromPosX(ImGui_Context ctx, number local_x, optional number center_x_ratioIn)
(ImGui_Context ctx, Float local_x, Float center_x_ratioInOptional) = ImGui_SetScrollFromPosX(ctx, local_x, center_x_ratioInOptional)

Adjust scrolling amount to make given position visible.
Generally GetCursorStartPos() + offset to compute a valid position.

void ImGui_SetScrollFromPosY(ImGui_Context* ctx, double local_y, double* center_y_ratioInOptional)
ImGui_SetScrollFromPosY(ImGui_Context ctx, local_y, optional center_y_ratioIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetScrollFromPosY", ImGui_Context ctx, local_y, optional center_y_ratioIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetScrollFromPosY(ImGui_Context ctx, number local_y, optional number center_y_ratioIn)
(ImGui_Context ctx, Float local_y, Float center_y_ratioInOptional) = ImGui_SetScrollFromPosY(ctx, local_y, center_y_ratioInOptional)

Adjust scrolling amount to make given position visible.
Generally GetCursorStartPos() + offset to compute a valid position.

void ImGui_SetScrollHereX(ImGui_Context* ctx, double* center_x_ratioInOptional)
ImGui_SetScrollHereX(ImGui_Context ctx, optional center_x_ratioIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetScrollHereX", ImGui_Context ctx, optional center_x_ratioIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetScrollHereX(ImGui_Context ctx, optional number center_x_ratioIn)
(ImGui_Context ctx, Float center_x_ratioInOptional) = ImGui_SetScrollHereX(ctx, center_x_ratioInOptional)

Adjust scrolling amount to make current cursor position visible.
center_x_ratio=0.0: left, 0.5: center, 1.0: right.
When using to make a "default/current item" visible,
consider using SetItemDefaultFocus instead.

void ImGui_SetScrollHereY(ImGui_Context* ctx, double* center_y_ratioInOptional)
ImGui_SetScrollHereY(ImGui_Context ctx, optional center_y_ratioIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetScrollHereY", ImGui_Context ctx, optional center_y_ratioIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetScrollHereY(ImGui_Context ctx, optional number center_y_ratioIn)
(ImGui_Context ctx, Float center_y_ratioInOptional) = ImGui_SetScrollHereY(ctx, center_y_ratioInOptional)

Adjust scrolling amount to make current cursor position visible.
center_y_ratio=0.0: top, 0.5: center, 1.0: bottom.
When using to make a "default/current item" visible,
consider using SetItemDefaultFocus instead.

void ImGui_SetScrollX(ImGui_Context* ctx, double scroll_x)
ImGui_SetScrollX(ImGui_Context ctx, scroll_x) (requires REAPER 6.24 or later)
extension_api("ImGui_SetScrollX", ImGui_Context ctx, scroll_x) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetScrollX(ImGui_Context ctx, number scroll_x)
ImGui_SetScrollX(ImGui_Context ctx, Float scroll_x)

Set scrolling amount [0 .. GetScrollMaxX()]

void ImGui_SetScrollY(ImGui_Context* ctx, double scroll_y)
ImGui_SetScrollY(ImGui_Context ctx, scroll_y) (requires REAPER 6.24 or later)
extension_api("ImGui_SetScrollY", ImGui_Context ctx, scroll_y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetScrollY(ImGui_Context ctx, number scroll_y)
ImGui_SetScrollY(ImGui_Context ctx, Float scroll_y)

Set scrolling amount [0 .. GetScrollMaxY()]

void ImGui_SetTabItemClosed(ImGui_Context* ctx, const char* tab_or_docked_window_label)
ImGui_SetTabItemClosed(ImGui_Context ctx, "tab_or_docked_window_label") (requires REAPER 6.24 or later)
extension_api("ImGui_SetTabItemClosed", ImGui_Context ctx, "tab_or_docked_window_label") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetTabItemClosed(ImGui_Context ctx, string tab_or_docked_window_label)
ImGui_SetTabItemClosed(ImGui_Context ctx, String tab_or_docked_window_label)

Notify TabBar or Docking system of a closed tab/window ahead
(useful to reduce visual flicker on reorderable tab bars).
For tab-bar: call after BeginTabBar and before Tab submissions.
Otherwise call with a window name.

void ImGui_SetTooltip(ImGui_Context* ctx, const char* text)
ImGui_SetTooltip(ImGui_Context ctx, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_SetTooltip", ImGui_Context ctx, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetTooltip(ImGui_Context ctx, string text)
ImGui_SetTooltip(ImGui_Context ctx, String text)

Set a text-only tooltip, typically use with IsItemHovered. override any
previous call to SetTooltip.

void ImGui_SetWindowCollapsed(ImGui_Context* ctx, bool collapsed, int* condInOptional)
ImGui_SetWindowCollapsed(ImGui_Context ctx, bool collapsed, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetWindowCollapsed", ImGui_Context ctx, bool collapsed, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetWindowCollapsed(ImGui_Context ctx, boolean collapsed, optional integer condIn)
(ImGui_Context ctx, Boolean collapsed, Int condInOptional) = ImGui_SetWindowCollapsed(ctx, collapsed, condInOptional)

(Not recommended) Set current window collapsed state.
Prefer using SetNextWindowCollapsed.

void ImGui_SetWindowCollapsedEx(ImGui_Context* ctx, const char* name, bool collapsed, int* condInOptional)
ImGui_SetWindowCollapsedEx(ImGui_Context ctx, "name", bool collapsed, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetWindowCollapsedEx", ImGui_Context ctx, "name", bool collapsed, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetWindowCollapsedEx(ImGui_Context ctx, string name, boolean collapsed, optional integer condIn)
(ImGui_Context ctx, String name, Boolean collapsed, Int condInOptional) = ImGui_SetWindowCollapsedEx(ctx, name, collapsed, condInOptional)

Set named window collapsed state.

void ImGui_SetWindowFocus(ImGui_Context* ctx)
ImGui_SetWindowFocus(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_SetWindowFocus", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetWindowFocus(ImGui_Context ctx)
ImGui_SetWindowFocus(ImGui_Context ctx)

(Not recommended) Set current window to be focused / top-most.
Prefer using SetNextWindowFocus.

void ImGui_SetWindowFocusEx(ImGui_Context* ctx, const char* name)
ImGui_SetWindowFocusEx(ImGui_Context ctx, "name") (requires REAPER 6.24 or later)
extension_api("ImGui_SetWindowFocusEx", ImGui_Context ctx, "name") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetWindowFocusEx(ImGui_Context ctx, string name)
ImGui_SetWindowFocusEx(ImGui_Context ctx, String name)

Set named window to be focused / top-most. Use an empty name to remove focus.

void ImGui_SetWindowPos(ImGui_Context* ctx, double pos_x, double pos_y, int* condInOptional)
ImGui_SetWindowPos(ImGui_Context ctx, pos_x, pos_y, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetWindowPos", ImGui_Context ctx, pos_x, pos_y, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetWindowPos(ImGui_Context ctx, number pos_x, number pos_y, optional integer condIn)
(ImGui_Context ctx, Float pos_x, Float pos_y, Int condInOptional) = ImGui_SetWindowPos(ctx, pos_x, pos_y, condInOptional)

(Not recommended) Set current window position - call within Begin/End.
Prefer using SetNextWindowPos, as this may incur tearing and minor side-effects.

void ImGui_SetWindowPosEx(ImGui_Context* ctx, const char* name, double pos_x, double pos_y, int* condInOptional)
ImGui_SetWindowPosEx(ImGui_Context ctx, "name", pos_x, pos_y, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetWindowPosEx", ImGui_Context ctx, "name", pos_x, pos_y, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetWindowPosEx(ImGui_Context ctx, string name, number pos_x, number pos_y, optional integer condIn)
(ImGui_Context ctx, String name, Float pos_x, Float pos_y, Int condInOptional) = ImGui_SetWindowPosEx(ctx, name, pos_x, pos_y, condInOptional)

Set named window position.

void ImGui_SetWindowSize(ImGui_Context* ctx, double size_w, double size_h, int* condInOptional)
ImGui_SetWindowSize(ImGui_Context ctx, size_w, size_h, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetWindowSize", ImGui_Context ctx, size_w, size_h, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetWindowSize(ImGui_Context ctx, number size_w, number size_h, optional integer condIn)
(ImGui_Context ctx, Float size_w, Float size_h, Int condInOptional) = ImGui_SetWindowSize(ctx, size_w, size_h, condInOptional)

(Not recommended) Set current window size - call within Begin/End.
Set size_w and size_h to 0 to force an auto-fit.
Prefer using SetNextWindowSize, as this may incur tearing and minor side-effects.

void ImGui_SetWindowSizeEx(ImGui_Context* ctx, const char* name, double size_w, double size_h, int* condInOptional)
ImGui_SetWindowSizeEx(ImGui_Context ctx, "name", size_w, size_h, optional int condIn) (requires REAPER 6.24 or later)
extension_api("ImGui_SetWindowSizeEx", ImGui_Context ctx, "name", size_w, size_h, optional int condIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_SetWindowSizeEx(ImGui_Context ctx, string name, number size_w, number size_h, optional integer condIn)
(ImGui_Context ctx, String name, Float size_w, Float size_h, Int condInOptional) = ImGui_SetWindowSizeEx(ctx, name, size_w, size_h, condInOptional)

Set named window size. Set axis to 0.0 to force an auto-fit on this axis.

void ImGui_ShowAboutWindow(ImGui_Context* ctx, bool* p_openInOutOptional)
ImGui_ShowAboutWindow(ImGui_Context ctx, optional bool &p_open) (requires REAPER 6.24 or later)
extension_api("ImGui_ShowAboutWindow", ImGui_Context ctx, optional bool &p_open) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
optional boolean p_open = reaper.ImGui_ShowAboutWindow(ImGui_Context ctx, optional boolean p_open)
(ImGui_Context ctx, Boolean p_openInOutOptional) = ImGui_ShowAboutWindow(ctx, p_openInOutOptional)

Create About window.
Display ReaImGui version, Dear ImGui version, credits and build/system information.

void ImGui_ShowDebugLogWindow(ImGui_Context* ctx, bool* p_openInOutOptional)
ImGui_ShowDebugLogWindow(ImGui_Context ctx, optional bool &p_open) (requires REAPER 6.24 or later)
extension_api("ImGui_ShowDebugLogWindow", ImGui_Context ctx, optional bool &p_open) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
optional boolean p_open = reaper.ImGui_ShowDebugLogWindow(ImGui_Context ctx, optional boolean p_open)
(ImGui_Context ctx, Boolean p_openInOutOptional) = ImGui_ShowDebugLogWindow(ctx, p_openInOutOptional)

Create Debug Log window. display a simplified log of important dear imgui events.

void ImGui_ShowMetricsWindow(ImGui_Context* ctx, bool* p_openInOutOptional)
ImGui_ShowMetricsWindow(ImGui_Context ctx, optional bool &p_open) (requires REAPER 6.24 or later)
extension_api("ImGui_ShowMetricsWindow", ImGui_Context ctx, optional bool &p_open) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
optional boolean p_open = reaper.ImGui_ShowMetricsWindow(ImGui_Context ctx, optional boolean p_open)
(ImGui_Context ctx, Boolean p_openInOutOptional) = ImGui_ShowMetricsWindow(ctx, p_openInOutOptional)

Create Metrics/Debugger window.
Display Dear ImGui internals: windows, draw commands, various internal state, etc.

void ImGui_ShowStackToolWindow(ImGui_Context* ctx, bool* p_openInOutOptional)
ImGui_ShowStackToolWindow(ImGui_Context ctx, optional bool &p_open) (requires REAPER 6.24 or later)
extension_api("ImGui_ShowStackToolWindow", ImGui_Context ctx, optional bool &p_open) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
optional boolean p_open = reaper.ImGui_ShowStackToolWindow(ImGui_Context ctx, optional boolean p_open)
(ImGui_Context ctx, Boolean p_openInOutOptional) = ImGui_ShowStackToolWindow(ctx, p_openInOutOptional)

Create Stack Tool window. Hover items with mouse to query information about
the source of their unique ID.

bool ImGui_SliderAngle(ImGui_Context* ctx, const char* label, double* v_radInOut, double* v_degrees_minInOptional, double* v_degrees_maxInOptional, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderAngle(ImGui_Context ctx, "label", &v_rad, optional v_degrees_minIn, optional v_degrees_maxIn, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderAngle", ImGui_Context ctx, "label", &v_rad, optional v_degrees_minIn, optional v_degrees_maxIn, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v_rad = reaper.ImGui_SliderAngle(ImGui_Context ctx, string label, number v_rad, optional number v_degrees_minIn, optional number v_degrees_maxIn, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v_radInOut, Float v_degrees_minInOptional, Float v_degrees_maxInOptional, String formatInOptional, Int flagsInOptional) = ImGui_SliderAngle(ctx, label, v_radInOut, v_degrees_minInOptional, v_degrees_maxInOptional, formatInOptional, flagsInOptional)
bool ImGui_SliderDouble(ImGui_Context* ctx, const char* label, double* vInOut, double v_min, double v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderDouble(ImGui_Context ctx, "label", &v, v_min, v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderDouble", ImGui_Context ctx, "label", &v, v_min, v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v = reaper.ImGui_SliderDouble(ImGui_Context ctx, string label, number v, number v_min, number v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float vInOut, Float v_min, Float v_max, String formatInOptional, Int flagsInOptional) = ImGui_SliderDouble(ctx, label, vInOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_SliderDouble2(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double v_min, double v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderDouble2(ImGui_Context ctx, "label", &v1, &v2, v_min, v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderDouble2", ImGui_Context ctx, "label", &v1, &v2, v_min, v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v1, number v2 = reaper.ImGui_SliderDouble2(ImGui_Context ctx, string label, number v1, number v2, number v_min, number v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v1InOut, Float v2InOut, Float v_min, Float v_max, String formatInOptional, Int flagsInOptional) = ImGui_SliderDouble2(ctx, label, v1InOut, v2InOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_SliderDouble3(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double v_min, double v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderDouble3(ImGui_Context ctx, "label", &v1, &v2, &v3, v_min, v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderDouble3", ImGui_Context ctx, "label", &v1, &v2, &v3, v_min, v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v1, number v2, number v3 = reaper.ImGui_SliderDouble3(ImGui_Context ctx, string label, number v1, number v2, number v3, number v_min, number v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v1InOut, Float v2InOut, Float v3InOut, Float v_min, Float v_max, String formatInOptional, Int flagsInOptional) = ImGui_SliderDouble3(ctx, label, v1InOut, v2InOut, v3InOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_SliderDouble4(ImGui_Context* ctx, const char* label, double* v1InOut, double* v2InOut, double* v3InOut, double* v4InOut, double v_min, double v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderDouble4(ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, v_min, v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderDouble4", ImGui_Context ctx, "label", &v1, &v2, &v3, &v4, v_min, v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v1, number v2, number v3, number v4 = reaper.ImGui_SliderDouble4(ImGui_Context ctx, string label, number v1, number v2, number v3, number v4, number v_min, number v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float v1InOut, Float v2InOut, Float v3InOut, Float v4InOut, Float v_min, Float v_max, String formatInOptional, Int flagsInOptional) = ImGui_SliderDouble4(ctx, label, v1InOut, v2InOut, v3InOut, v4InOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_SliderDoubleN(ImGui_Context* ctx, const char* label, reaper_array* values, double v_min, double v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderDoubleN(ImGui_Context ctx, "label", reaper_array values, v_min, v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderDoubleN", ImGui_Context ctx, "label", reaper_array values, v_min, v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_SliderDoubleN(ImGui_Context ctx, string label, reaper_array values, number v_min, number v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, reaper_array values, Float v_min, Float v_max, String formatInOptional, Int flagsInOptional) = ImGui_SliderDoubleN(ctx, label, values, v_min, v_max, formatInOptional, flagsInOptional)
int ImGui_SliderFlags_AlwaysClamp()
int ImGui_SliderFlags_AlwaysClamp() (requires REAPER 6.24 or later)
int extension_api("ImGui_SliderFlags_AlwaysClamp") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SliderFlags_AlwaysClamp()
Int ImGui_SliderFlags_AlwaysClamp()

Clamp value to min/max bounds when input manually with CTRL+Click.
By default CTRL+Click allows going out of bounds.

int ImGui_SliderFlags_Logarithmic()
int ImGui_SliderFlags_Logarithmic() (requires REAPER 6.24 or later)
int extension_api("ImGui_SliderFlags_Logarithmic") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SliderFlags_Logarithmic()
Int ImGui_SliderFlags_Logarithmic()

Make the widget logarithmic (linear otherwise).
Consider using SliderFlags_NoRoundToFormat with this if using a format-string
with small amount of digits.

int ImGui_SliderFlags_NoInput()
int ImGui_SliderFlags_NoInput() (requires REAPER 6.24 or later)
int extension_api("ImGui_SliderFlags_NoInput") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SliderFlags_NoInput()
Int ImGui_SliderFlags_NoInput()

Disable CTRL+Click or Enter key allowing to input text directly into the widget.

int ImGui_SliderFlags_NoRoundToFormat()
int ImGui_SliderFlags_NoRoundToFormat() (requires REAPER 6.24 or later)
int extension_api("ImGui_SliderFlags_NoRoundToFormat") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SliderFlags_NoRoundToFormat()
Int ImGui_SliderFlags_NoRoundToFormat()

Disable rounding underlying value to match precision of the display format
string (e.g. %.3f values are rounded to those 3 digits).

int ImGui_SliderFlags_None()
int ImGui_SliderFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_SliderFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SliderFlags_None()
Int ImGui_SliderFlags_None()
bool ImGui_SliderInt(ImGui_Context* ctx, const char* label, int* vInOut, int v_min, int v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderInt(ImGui_Context ctx, "label", int &v, int v_min, int v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderInt", ImGui_Context ctx, "label", int &v, int v_min, int v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v = reaper.ImGui_SliderInt(ImGui_Context ctx, string label, integer v, integer v_min, integer v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int vInOut, Int v_min, Int v_max, String formatInOptional, Int flagsInOptional) = ImGui_SliderInt(ctx, label, vInOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_SliderInt2(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int v_min, int v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderInt2(ImGui_Context ctx, "label", int &v1, int &v2, int v_min, int v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderInt2", ImGui_Context ctx, "label", int &v1, int &v2, int v_min, int v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v1, integer v2 = reaper.ImGui_SliderInt2(ImGui_Context ctx, string label, integer v1, integer v2, integer v_min, integer v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v1InOut, Int v2InOut, Int v_min, Int v_max, String formatInOptional, Int flagsInOptional) = ImGui_SliderInt2(ctx, label, v1InOut, v2InOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_SliderInt3(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int v_min, int v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderInt3(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int v_min, int v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderInt3", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int v_min, int v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v1, integer v2, integer v3 = reaper.ImGui_SliderInt3(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, integer v_min, integer v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v1InOut, Int v2InOut, Int v3InOut, Int v_min, Int v_max, String formatInOptional, Int flagsInOptional) = ImGui_SliderInt3(ctx, label, v1InOut, v2InOut, v3InOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_SliderInt4(ImGui_Context* ctx, const char* label, int* v1InOut, int* v2InOut, int* v3InOut, int* v4InOut, int v_min, int v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_SliderInt4(ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, int v_min, int v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_SliderInt4", ImGui_Context ctx, "label", int &v1, int &v2, int &v3, int &v4, int v_min, int v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v1, integer v2, integer v3, integer v4 = reaper.ImGui_SliderInt4(ImGui_Context ctx, string label, integer v1, integer v2, integer v3, integer v4, integer v_min, integer v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int v1InOut, Int v2InOut, Int v3InOut, Int v4InOut, Int v_min, Int v_max, String formatInOptional, Int flagsInOptional) = ImGui_SliderInt4(ctx, label, v1InOut, v2InOut, v3InOut, v4InOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_SmallButton(ImGui_Context* ctx, const char* label)
bool ImGui_SmallButton(ImGui_Context ctx, "label") (requires REAPER 6.24 or later)
bool extension_api("ImGui_SmallButton", ImGui_Context ctx, "label") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_SmallButton(ImGui_Context ctx, string label)
Boolean ImGui_SmallButton(ImGui_Context ctx, String label)

Button with StyleVar_FramePadding=(0,0) to easily embed within text.

int ImGui_SortDirection_Ascending()
int ImGui_SortDirection_Ascending() (requires REAPER 6.24 or later)
int extension_api("ImGui_SortDirection_Ascending") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SortDirection_Ascending()
Int ImGui_SortDirection_Ascending()

Ascending = 0->9, A->Z etc.

int ImGui_SortDirection_Descending()
int ImGui_SortDirection_Descending() (requires REAPER 6.24 or later)
int extension_api("ImGui_SortDirection_Descending") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SortDirection_Descending()
Int ImGui_SortDirection_Descending()

Descending = 9->0, Z->A etc.

int ImGui_SortDirection_None()
int ImGui_SortDirection_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_SortDirection_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_SortDirection_None()
Int ImGui_SortDirection_None()
void ImGui_Spacing(ImGui_Context* ctx)
ImGui_Spacing(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_Spacing", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Spacing(ImGui_Context ctx)
ImGui_Spacing(ImGui_Context ctx)

Add vertical spacing.

int ImGui_StyleVar_Alpha()
int ImGui_StyleVar_Alpha() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_Alpha") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_Alpha()
Int ImGui_StyleVar_Alpha()

Global alpha applies to everything in Dear ImGui.

int ImGui_StyleVar_ButtonTextAlign()
int ImGui_StyleVar_ButtonTextAlign() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_ButtonTextAlign") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_ButtonTextAlign()
Int ImGui_StyleVar_ButtonTextAlign()

Alignment of button text when button is larger than text.
Defaults to (0.5, 0.5) (centered).

int ImGui_StyleVar_CellPadding()
int ImGui_StyleVar_CellPadding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_CellPadding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_CellPadding()
Int ImGui_StyleVar_CellPadding()

Padding within a table cell.

int ImGui_StyleVar_ChildBorderSize()
int ImGui_StyleVar_ChildBorderSize() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_ChildBorderSize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_ChildBorderSize()
Int ImGui_StyleVar_ChildBorderSize()

Thickness of border around child windows. Generally set to 0.0 or 1.0.
(Other values are not well tested and more CPU/GPU costly).

int ImGui_StyleVar_ChildRounding()
int ImGui_StyleVar_ChildRounding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_ChildRounding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_ChildRounding()
Int ImGui_StyleVar_ChildRounding()

Radius of child window corners rounding. Set to 0.0 to have rectangular windows.

int ImGui_StyleVar_DisabledAlpha()
int ImGui_StyleVar_DisabledAlpha() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_DisabledAlpha") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_DisabledAlpha()
Int ImGui_StyleVar_DisabledAlpha()

Additional alpha multiplier applied by BeginDisabled.
Multiply over current value of Alpha.

int ImGui_StyleVar_FrameBorderSize()
int ImGui_StyleVar_FrameBorderSize() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_FrameBorderSize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_FrameBorderSize()
Int ImGui_StyleVar_FrameBorderSize()

Thickness of border around frames. Generally set to 0.0 or 1.0.
(Other values are not well tested and more CPU/GPU costly).

int ImGui_StyleVar_FramePadding()
int ImGui_StyleVar_FramePadding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_FramePadding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_FramePadding()
Int ImGui_StyleVar_FramePadding()

Padding within a framed rectangle (used by most widgets).

int ImGui_StyleVar_FrameRounding()
int ImGui_StyleVar_FrameRounding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_FrameRounding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_FrameRounding()
Int ImGui_StyleVar_FrameRounding()

Radius of frame corners rounding.
Set to 0.0 to have rectangular frame (used by most widgets).

int ImGui_StyleVar_GrabMinSize()
int ImGui_StyleVar_GrabMinSize() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_GrabMinSize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_GrabMinSize()
Int ImGui_StyleVar_GrabMinSize()

Minimum width/height of a grab box for slider/scrollbar.

int ImGui_StyleVar_GrabRounding()
int ImGui_StyleVar_GrabRounding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_GrabRounding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_GrabRounding()
Int ImGui_StyleVar_GrabRounding()

Radius of grabs corners rounding. Set to 0.0 to have rectangular slider grabs.

int ImGui_StyleVar_IndentSpacing()
int ImGui_StyleVar_IndentSpacing() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_IndentSpacing") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_IndentSpacing()
Int ImGui_StyleVar_IndentSpacing()

Horizontal indentation when e.g. entering a tree node.
Generally == (GetFontSize + StyleVar_FramePadding.x*2).

int ImGui_StyleVar_ItemInnerSpacing()
int ImGui_StyleVar_ItemInnerSpacing() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_ItemInnerSpacing") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_ItemInnerSpacing()
Int ImGui_StyleVar_ItemInnerSpacing()

Horizontal and vertical spacing between within elements of a composed widget
(e.g. a slider and its label).

int ImGui_StyleVar_ItemSpacing()
int ImGui_StyleVar_ItemSpacing() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_ItemSpacing") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_ItemSpacing()
Int ImGui_StyleVar_ItemSpacing()

Horizontal and vertical spacing between widgets/lines.

int ImGui_StyleVar_PopupBorderSize()
int ImGui_StyleVar_PopupBorderSize() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_PopupBorderSize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_PopupBorderSize()
Int ImGui_StyleVar_PopupBorderSize()

Thickness of border around popup/tooltip windows. Generally set to 0.0 or 1.0.
(Other values are not well tested and more CPU/GPU costly).

int ImGui_StyleVar_PopupRounding()
int ImGui_StyleVar_PopupRounding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_PopupRounding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_PopupRounding()
Int ImGui_StyleVar_PopupRounding()

Radius of popup window corners rounding.
(Note that tooltip windows use StyleVar_WindowRounding.)

int ImGui_StyleVar_ScrollbarRounding()
int ImGui_StyleVar_ScrollbarRounding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_ScrollbarRounding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_ScrollbarRounding()
Int ImGui_StyleVar_ScrollbarRounding()

Radius of grab corners for scrollbar.

int ImGui_StyleVar_ScrollbarSize()
int ImGui_StyleVar_ScrollbarSize() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_ScrollbarSize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_ScrollbarSize()
Int ImGui_StyleVar_ScrollbarSize()

Width of the vertical scrollbar, Height of the horizontal scrollbar.

int ImGui_StyleVar_SelectableTextAlign()
int ImGui_StyleVar_SelectableTextAlign() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_SelectableTextAlign") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_SelectableTextAlign()
Int ImGui_StyleVar_SelectableTextAlign()

Alignment of selectable text. Defaults to (0.0, 0.0) (top-left aligned).
It's generally important to keep this left-aligned if you want to lay
multiple items on a same line.

int ImGui_StyleVar_SeparatorTextAlign()
int ImGui_StyleVar_SeparatorTextAlign() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_SeparatorTextAlign") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_SeparatorTextAlign()
Int ImGui_StyleVar_SeparatorTextAlign()

Alignment of text within the separator.
Defaults to (0.0, 0.5) (left aligned, center).

int ImGui_StyleVar_SeparatorTextBorderSize()
int ImGui_StyleVar_SeparatorTextBorderSize() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_SeparatorTextBorderSize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_SeparatorTextBorderSize()
Int ImGui_StyleVar_SeparatorTextBorderSize()

Thickness of border in SeparatorText()

int ImGui_StyleVar_SeparatorTextPadding()
int ImGui_StyleVar_SeparatorTextPadding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_SeparatorTextPadding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_SeparatorTextPadding()
Int ImGui_StyleVar_SeparatorTextPadding()

Horizontal offset of text from each edge of the separator + spacing on other
axis. Generally small values. .y is recommended to be == StyleVar_FramePadding.y.

int ImGui_StyleVar_TabRounding()
int ImGui_StyleVar_TabRounding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_TabRounding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_TabRounding()
Int ImGui_StyleVar_TabRounding()

Radius of upper corners of a tab. Set to 0.0 to have rectangular tabs.

int ImGui_StyleVar_WindowBorderSize()
int ImGui_StyleVar_WindowBorderSize() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_WindowBorderSize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_WindowBorderSize()
Int ImGui_StyleVar_WindowBorderSize()

Thickness of border around windows. Generally set to 0.0 or 1.0.
(Other values are not well tested and more CPU/GPU costly).

int ImGui_StyleVar_WindowMinSize()
int ImGui_StyleVar_WindowMinSize() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_WindowMinSize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_WindowMinSize()
Int ImGui_StyleVar_WindowMinSize()

Minimum window size. This is a global setting.
If you want to constrain individual windows, use SetNextWindowSizeConstraints.

int ImGui_StyleVar_WindowPadding()
int ImGui_StyleVar_WindowPadding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_WindowPadding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_WindowPadding()
Int ImGui_StyleVar_WindowPadding()

Padding within a window.

int ImGui_StyleVar_WindowRounding()
int ImGui_StyleVar_WindowRounding() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_WindowRounding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_WindowRounding()
Int ImGui_StyleVar_WindowRounding()

Radius of window corners rounding. Set to 0.0 to have rectangular windows.
Large values tend to lead to variety of artifacts and are not recommended.

int ImGui_StyleVar_WindowTitleAlign()
int ImGui_StyleVar_WindowTitleAlign() (requires REAPER 6.24 or later)
int extension_api("ImGui_StyleVar_WindowTitleAlign") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_StyleVar_WindowTitleAlign()
Int ImGui_StyleVar_WindowTitleAlign()

Alignment for title bar text.
Defaults to (0.0,0.5) for left-aligned,vertically centered.

int ImGui_TabBarFlags_AutoSelectNewTabs()
int ImGui_TabBarFlags_AutoSelectNewTabs() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabBarFlags_AutoSelectNewTabs") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabBarFlags_AutoSelectNewTabs()
Int ImGui_TabBarFlags_AutoSelectNewTabs()

Automatically select new tabs when they appear.

int ImGui_TabBarFlags_FittingPolicyResizeDown()
int ImGui_TabBarFlags_FittingPolicyResizeDown() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabBarFlags_FittingPolicyResizeDown") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabBarFlags_FittingPolicyResizeDown()
Int ImGui_TabBarFlags_FittingPolicyResizeDown()

Resize tabs when they don't fit.

int ImGui_TabBarFlags_FittingPolicyScroll()
int ImGui_TabBarFlags_FittingPolicyScroll() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabBarFlags_FittingPolicyScroll") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabBarFlags_FittingPolicyScroll()
Int ImGui_TabBarFlags_FittingPolicyScroll()

Add scroll buttons when tabs don't fit.

int ImGui_TabBarFlags_NoCloseWithMiddleMouseButton()
int ImGui_TabBarFlags_NoCloseWithMiddleMouseButton() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabBarFlags_NoCloseWithMiddleMouseButton") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabBarFlags_NoCloseWithMiddleMouseButton()
Int ImGui_TabBarFlags_NoCloseWithMiddleMouseButton()

Disable behavior of closing tabs (that are submitted with p_open != nil)
with middle mouse button. You can still repro this behavior on user's side
with if(IsItemHovered() && IsMouseClicked(2)) p_open = false.

int ImGui_TabBarFlags_NoTabListScrollingButtons()
int ImGui_TabBarFlags_NoTabListScrollingButtons() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabBarFlags_NoTabListScrollingButtons") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabBarFlags_NoTabListScrollingButtons()
Int ImGui_TabBarFlags_NoTabListScrollingButtons()

Disable scrolling buttons (apply when fitting policy is
TabBarFlags_FittingPolicyScroll).

int ImGui_TabBarFlags_NoTooltip()
int ImGui_TabBarFlags_NoTooltip() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabBarFlags_NoTooltip") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabBarFlags_NoTooltip()
Int ImGui_TabBarFlags_NoTooltip()

Disable tooltips when hovering a tab.

int ImGui_TabBarFlags_None()
int ImGui_TabBarFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabBarFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabBarFlags_None()
Int ImGui_TabBarFlags_None()
int ImGui_TabBarFlags_Reorderable()
int ImGui_TabBarFlags_Reorderable() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabBarFlags_Reorderable") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabBarFlags_Reorderable()
Int ImGui_TabBarFlags_Reorderable()

Allow manually dragging tabs to re-order them + New tabs are appended at
the end of list.

int ImGui_TabBarFlags_TabListPopupButton()
int ImGui_TabBarFlags_TabListPopupButton() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabBarFlags_TabListPopupButton") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabBarFlags_TabListPopupButton()
Int ImGui_TabBarFlags_TabListPopupButton()

Disable buttons to open the tab list popup.

bool ImGui_TabItemButton(ImGui_Context* ctx, const char* label, int* flagsInOptional)
bool ImGui_TabItemButton(ImGui_Context ctx, "label", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TabItemButton", ImGui_Context ctx, "label", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_TabItemButton(ImGui_Context ctx, string label, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int flagsInOptional) = ImGui_TabItemButton(ctx, label, flagsInOptional)

Create a Tab behaving like a button. Return true when clicked.
Cannot be selected in the tab bar.

int ImGui_TabItemFlags_Leading()
int ImGui_TabItemFlags_Leading() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabItemFlags_Leading") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabItemFlags_Leading()
Int ImGui_TabItemFlags_Leading()

Enforce the tab position to the left of the tab bar (after the tab list popup button).

int ImGui_TabItemFlags_NoCloseWithMiddleMouseButton()
int ImGui_TabItemFlags_NoCloseWithMiddleMouseButton() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabItemFlags_NoCloseWithMiddleMouseButton") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabItemFlags_NoCloseWithMiddleMouseButton()
Int ImGui_TabItemFlags_NoCloseWithMiddleMouseButton()

Disable behavior of closing tabs (that are submitted with p_open != nil) with
middle mouse button. You can still repro this behavior on user's side with
if(IsItemHovered() && IsMouseClicked(2)) p_open = false.

int ImGui_TabItemFlags_NoPushId()
int ImGui_TabItemFlags_NoPushId() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabItemFlags_NoPushId") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabItemFlags_NoPushId()
Int ImGui_TabItemFlags_NoPushId()

Don't call PushID(tab->ID)/PopID() on BeginTabItem/EndTabItem.

int ImGui_TabItemFlags_NoReorder()
int ImGui_TabItemFlags_NoReorder() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabItemFlags_NoReorder") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabItemFlags_NoReorder()
Int ImGui_TabItemFlags_NoReorder()

Disable reordering this tab or having another tab cross over this tab.

int ImGui_TabItemFlags_NoTooltip()
int ImGui_TabItemFlags_NoTooltip() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabItemFlags_NoTooltip") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabItemFlags_NoTooltip()
Int ImGui_TabItemFlags_NoTooltip()

Disable tooltip for the given tab.

int ImGui_TabItemFlags_None()
int ImGui_TabItemFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabItemFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabItemFlags_None()
Int ImGui_TabItemFlags_None()
int ImGui_TabItemFlags_SetSelected()
int ImGui_TabItemFlags_SetSelected() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabItemFlags_SetSelected") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabItemFlags_SetSelected()
Int ImGui_TabItemFlags_SetSelected()

Trigger flag to programmatically make the tab selected when calling BeginTabItem.

int ImGui_TabItemFlags_Trailing()
int ImGui_TabItemFlags_Trailing() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabItemFlags_Trailing") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabItemFlags_Trailing()
Int ImGui_TabItemFlags_Trailing()

Enforce the tab position to the right of the tab bar (before the scrolling buttons).

int ImGui_TabItemFlags_UnsavedDocument()
int ImGui_TabItemFlags_UnsavedDocument() (requires REAPER 6.24 or later)
int extension_api("ImGui_TabItemFlags_UnsavedDocument") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TabItemFlags_UnsavedDocument()
Int ImGui_TabItemFlags_UnsavedDocument()

Append '*' to title without affecting the ID, as a convenience to avoid using
the ### operator. Also: tab is selected on closure and closure is deferred by
one frame to allow code to undo it without flicker.

int ImGui_TableBgTarget_CellBg()
int ImGui_TableBgTarget_CellBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableBgTarget_CellBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableBgTarget_CellBg()
Int ImGui_TableBgTarget_CellBg()

Set cell background color (top-most color).

int ImGui_TableBgTarget_None()
int ImGui_TableBgTarget_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableBgTarget_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableBgTarget_None()
Int ImGui_TableBgTarget_None()
int ImGui_TableBgTarget_RowBg0()
int ImGui_TableBgTarget_RowBg0() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableBgTarget_RowBg0") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableBgTarget_RowBg0()
Int ImGui_TableBgTarget_RowBg0()

Set row background color 0 (generally used for background,
automatically set when TableFlags_RowBg is used).

int ImGui_TableBgTarget_RowBg1()
int ImGui_TableBgTarget_RowBg1() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableBgTarget_RowBg1") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableBgTarget_RowBg1()
Int ImGui_TableBgTarget_RowBg1()

Set row background color 1 (generally used for selection marking).

int ImGui_TableColumnFlags_DefaultHide()
int ImGui_TableColumnFlags_DefaultHide() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_DefaultHide") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_DefaultHide()
Int ImGui_TableColumnFlags_DefaultHide()

Default as a hidden/disabled column.

int ImGui_TableColumnFlags_DefaultSort()
int ImGui_TableColumnFlags_DefaultSort() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_DefaultSort") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_DefaultSort()
Int ImGui_TableColumnFlags_DefaultSort()

Default as a sorting column.

int ImGui_TableColumnFlags_Disabled()
int ImGui_TableColumnFlags_Disabled() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_Disabled") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_Disabled()
Int ImGui_TableColumnFlags_Disabled()

Overriding/master disable flag: hide column, won't show in context menu
(unlike calling TableSetColumnEnabled which manipulates the user accessible state).

int ImGui_TableColumnFlags_IndentDisable()
int ImGui_TableColumnFlags_IndentDisable() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_IndentDisable") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_IndentDisable()
Int ImGui_TableColumnFlags_IndentDisable()

Ignore current Indent value when entering cell (default for columns > 0).
Indentation changes _within_ the cell will still be honored.

int ImGui_TableColumnFlags_IndentEnable()
int ImGui_TableColumnFlags_IndentEnable() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_IndentEnable") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_IndentEnable()
Int ImGui_TableColumnFlags_IndentEnable()

Use current Indent value when entering cell (default for column 0).

int ImGui_TableColumnFlags_IsEnabled()
int ImGui_TableColumnFlags_IsEnabled() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_IsEnabled") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_IsEnabled()
Int ImGui_TableColumnFlags_IsEnabled()

Status: is enabled == not hidden by user/api (referred to as "Hide" in
_DefaultHide and _NoHide) flags.

int ImGui_TableColumnFlags_IsHovered()
int ImGui_TableColumnFlags_IsHovered() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_IsHovered") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_IsHovered()
Int ImGui_TableColumnFlags_IsHovered()

Status: is hovered by mouse.

int ImGui_TableColumnFlags_IsSorted()
int ImGui_TableColumnFlags_IsSorted() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_IsSorted") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_IsSorted()
Int ImGui_TableColumnFlags_IsSorted()

Status: is currently part of the sort specs.

int ImGui_TableColumnFlags_IsVisible()
int ImGui_TableColumnFlags_IsVisible() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_IsVisible") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_IsVisible()
Int ImGui_TableColumnFlags_IsVisible()

Status: is visible == is enabled AND not clipped by scrolling.

int ImGui_TableColumnFlags_NoClip()
int ImGui_TableColumnFlags_NoClip() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_NoClip") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_NoClip()
Int ImGui_TableColumnFlags_NoClip()

Disable clipping for this column
(all NoClip columns will render in a same draw command).

int ImGui_TableColumnFlags_NoHeaderLabel()
int ImGui_TableColumnFlags_NoHeaderLabel() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_NoHeaderLabel") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_NoHeaderLabel()
Int ImGui_TableColumnFlags_NoHeaderLabel()

TableHeadersRow will not submit label for this column.
Convenient for some small columns. Name will still appear in context menu.

int ImGui_TableColumnFlags_NoHeaderWidth()
int ImGui_TableColumnFlags_NoHeaderWidth() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_NoHeaderWidth") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_NoHeaderWidth()
Int ImGui_TableColumnFlags_NoHeaderWidth()

Disable header text width contribution to automatic column width.

int ImGui_TableColumnFlags_NoHide()
int ImGui_TableColumnFlags_NoHide() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_NoHide") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_NoHide()
Int ImGui_TableColumnFlags_NoHide()

Disable ability to hide/disable this column.

int ImGui_TableColumnFlags_NoReorder()
int ImGui_TableColumnFlags_NoReorder() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_NoReorder") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_NoReorder()
Int ImGui_TableColumnFlags_NoReorder()

Disable manual reordering this column, this will also prevent other columns
from crossing over this column.

int ImGui_TableColumnFlags_NoResize()
int ImGui_TableColumnFlags_NoResize() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_NoResize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_NoResize()
Int ImGui_TableColumnFlags_NoResize()

Disable manual resizing.

int ImGui_TableColumnFlags_NoSort()
int ImGui_TableColumnFlags_NoSort() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_NoSort") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_NoSort()
Int ImGui_TableColumnFlags_NoSort()

Disable ability to sort on this field
(even if TableFlags_Sortable is set on the table).

int ImGui_TableColumnFlags_NoSortAscending()
int ImGui_TableColumnFlags_NoSortAscending() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_NoSortAscending") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_NoSortAscending()
Int ImGui_TableColumnFlags_NoSortAscending()

Disable ability to sort in the ascending direction.

int ImGui_TableColumnFlags_NoSortDescending()
int ImGui_TableColumnFlags_NoSortDescending() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_NoSortDescending") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_NoSortDescending()
Int ImGui_TableColumnFlags_NoSortDescending()

Disable ability to sort in the descending direction.

int ImGui_TableColumnFlags_None()
int ImGui_TableColumnFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_None()
Int ImGui_TableColumnFlags_None()
int ImGui_TableColumnFlags_PreferSortAscending()
int ImGui_TableColumnFlags_PreferSortAscending() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_PreferSortAscending") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_PreferSortAscending()
Int ImGui_TableColumnFlags_PreferSortAscending()

Make the initial sort direction Ascending when first sorting on this column (default).

int ImGui_TableColumnFlags_PreferSortDescending()
int ImGui_TableColumnFlags_PreferSortDescending() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_PreferSortDescending") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_PreferSortDescending()
Int ImGui_TableColumnFlags_PreferSortDescending()

Make the initial sort direction Descending when first sorting on this column.

int ImGui_TableColumnFlags_WidthFixed()
int ImGui_TableColumnFlags_WidthFixed() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_WidthFixed") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_WidthFixed()
Int ImGui_TableColumnFlags_WidthFixed()

Column will not stretch. Preferable with horizontal scrolling enabled
(default if table sizing policy is _SizingFixedFit and table is resizable).

int ImGui_TableColumnFlags_WidthStretch()
int ImGui_TableColumnFlags_WidthStretch() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableColumnFlags_WidthStretch") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableColumnFlags_WidthStretch()
Int ImGui_TableColumnFlags_WidthStretch()

Column will stretch. Preferable with horizontal scrolling disabled
(default if table sizing policy is _SizingStretchSame or _SizingStretchProp).

int ImGui_TableFlags_Borders()
int ImGui_TableFlags_Borders() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_Borders") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_Borders()
Int ImGui_TableFlags_Borders()

Draw all borders.

int ImGui_TableFlags_BordersH()
int ImGui_TableFlags_BordersH() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_BordersH") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_BordersH()
Int ImGui_TableFlags_BordersH()

Draw horizontal borders.

int ImGui_TableFlags_BordersInner()
int ImGui_TableFlags_BordersInner() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_BordersInner") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_BordersInner()
Int ImGui_TableFlags_BordersInner()

Draw inner borders.

int ImGui_TableFlags_BordersInnerH()
int ImGui_TableFlags_BordersInnerH() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_BordersInnerH") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_BordersInnerH()
Int ImGui_TableFlags_BordersInnerH()

Draw horizontal borders between rows.

int ImGui_TableFlags_BordersInnerV()
int ImGui_TableFlags_BordersInnerV() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_BordersInnerV") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_BordersInnerV()
Int ImGui_TableFlags_BordersInnerV()

Draw vertical borders between columns.

int ImGui_TableFlags_BordersOuter()
int ImGui_TableFlags_BordersOuter() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_BordersOuter") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_BordersOuter()
Int ImGui_TableFlags_BordersOuter()

Draw outer borders.

int ImGui_TableFlags_BordersOuterH()
int ImGui_TableFlags_BordersOuterH() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_BordersOuterH") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_BordersOuterH()
Int ImGui_TableFlags_BordersOuterH()

Draw horizontal borders at the top and bottom.

int ImGui_TableFlags_BordersOuterV()
int ImGui_TableFlags_BordersOuterV() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_BordersOuterV") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_BordersOuterV()
Int ImGui_TableFlags_BordersOuterV()

Draw vertical borders on the left and right sides.

int ImGui_TableFlags_BordersV()
int ImGui_TableFlags_BordersV() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_BordersV") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_BordersV()
Int ImGui_TableFlags_BordersV()

Draw vertical borders.

int ImGui_TableFlags_ContextMenuInBody()
int ImGui_TableFlags_ContextMenuInBody() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_ContextMenuInBody") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_ContextMenuInBody()
Int ImGui_TableFlags_ContextMenuInBody()

Right-click on columns body/contents will display table context menu.
By default it is available in TableHeadersRow.

int ImGui_TableFlags_Hideable()
int ImGui_TableFlags_Hideable() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_Hideable") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_Hideable()
Int ImGui_TableFlags_Hideable()

Enable hiding/disabling columns in context menu.

int ImGui_TableFlags_NoClip()
int ImGui_TableFlags_NoClip() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_NoClip") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_NoClip()
Int ImGui_TableFlags_NoClip()

Disable clipping rectangle for every individual columns
(reduce draw command count, items will be able to overflow into other columns).
Generally incompatible with TableSetupScrollFreeze.

int ImGui_TableFlags_NoHostExtendX()
int ImGui_TableFlags_NoHostExtendX() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_NoHostExtendX") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_NoHostExtendX()
Int ImGui_TableFlags_NoHostExtendX()

Make outer width auto-fit to columns, overriding outer_size.x value. Only
available when ScrollX/ScrollY are disabled and Stretch columns are not used.

int ImGui_TableFlags_NoHostExtendY()
int ImGui_TableFlags_NoHostExtendY() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_NoHostExtendY") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_NoHostExtendY()
Int ImGui_TableFlags_NoHostExtendY()

Make outer height stop exactly at outer_size.y (prevent auto-extending table
past the limit). Only available when ScrollX/ScrollY are disabled.
Data below the limit will be clipped and not visible.

int ImGui_TableFlags_NoKeepColumnsVisible()
int ImGui_TableFlags_NoKeepColumnsVisible() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_NoKeepColumnsVisible") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_NoKeepColumnsVisible()
Int ImGui_TableFlags_NoKeepColumnsVisible()

Disable keeping column always minimally visible when ScrollX is off and table
gets too small. Not recommended if columns are resizable.

int ImGui_TableFlags_NoPadInnerX()
int ImGui_TableFlags_NoPadInnerX() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_NoPadInnerX") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_NoPadInnerX()
Int ImGui_TableFlags_NoPadInnerX()

Disable inner padding between columns (double inner padding if
TableFlags_BordersOuterV is on, single inner padding if BordersOuterV is off).

int ImGui_TableFlags_NoPadOuterX()
int ImGui_TableFlags_NoPadOuterX() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_NoPadOuterX") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_NoPadOuterX()
Int ImGui_TableFlags_NoPadOuterX()

Default if TableFlags_BordersOuterV is off. Disable outermost padding.

int ImGui_TableFlags_NoSavedSettings()
int ImGui_TableFlags_NoSavedSettings() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_NoSavedSettings") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_NoSavedSettings()
Int ImGui_TableFlags_NoSavedSettings()

Disable persisting columns order, width and sort settings in the .ini file.

int ImGui_TableFlags_None()
int ImGui_TableFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_None()
Int ImGui_TableFlags_None()
int ImGui_TableFlags_PadOuterX()
int ImGui_TableFlags_PadOuterX() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_PadOuterX") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_PadOuterX()
Int ImGui_TableFlags_PadOuterX()

Default if TableFlags_BordersOuterV is on. Enable outermost padding.
Generally desirable if you have headers.

int ImGui_TableFlags_PreciseWidths()
int ImGui_TableFlags_PreciseWidths() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_PreciseWidths") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_PreciseWidths()
Int ImGui_TableFlags_PreciseWidths()

Disable distributing remainder width to stretched columns (width allocation
on a 100-wide table with 3 columns: Without this flag: 33,33,34. With this
flag: 33,33,33).
With larger number of columns, resizing will appear to be less smooth.

int ImGui_TableFlags_Reorderable()
int ImGui_TableFlags_Reorderable() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_Reorderable") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_Reorderable()
Int ImGui_TableFlags_Reorderable()

Enable reordering columns in header row
(need calling TableSetupColumn + TableHeadersRow to display headers).

int ImGui_TableFlags_Resizable()
int ImGui_TableFlags_Resizable() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_Resizable") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_Resizable()
Int ImGui_TableFlags_Resizable()

Enable resizing columns.

int ImGui_TableFlags_RowBg()
int ImGui_TableFlags_RowBg() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_RowBg") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_RowBg()
Int ImGui_TableFlags_RowBg()

Set each RowBg color with Col_TableRowBg or Col_TableRowBgAlt (equivalent of
calling TableSetBgColor with TableBgTarget_RowBg0 on each row manually).

int ImGui_TableFlags_ScrollX()
int ImGui_TableFlags_ScrollX() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_ScrollX") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_ScrollX()
Int ImGui_TableFlags_ScrollX()

Enable horizontal scrolling. Require 'outer_size' parameter of BeginTable to
specify the container size. Changes default sizing policy.
Because this creates a child window, ScrollY is currently generally
recommended when using ScrollX.

int ImGui_TableFlags_ScrollY()
int ImGui_TableFlags_ScrollY() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_ScrollY") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_ScrollY()
Int ImGui_TableFlags_ScrollY()

Enable vertical scrolling.
Require 'outer_size' parameter of BeginTable to specify the container size.

int ImGui_TableFlags_SizingFixedFit()
int ImGui_TableFlags_SizingFixedFit() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_SizingFixedFit") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_SizingFixedFit()
Int ImGui_TableFlags_SizingFixedFit()

Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable),
matching contents width.

int ImGui_TableFlags_SizingFixedSame()
int ImGui_TableFlags_SizingFixedSame() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_SizingFixedSame") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_SizingFixedSame()
Int ImGui_TableFlags_SizingFixedSame()

Columns default to _WidthFixed or _WidthAuto (if resizable or not resizable),
matching the maximum contents width of all columns.
Implicitly enable TableFlags_NoKeepColumnsVisible.

int ImGui_TableFlags_SizingStretchProp()
int ImGui_TableFlags_SizingStretchProp() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_SizingStretchProp") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_SizingStretchProp()
Int ImGui_TableFlags_SizingStretchProp()

Columns default to _WidthStretch with default weights proportional to each
columns contents widths.

int ImGui_TableFlags_SizingStretchSame()
int ImGui_TableFlags_SizingStretchSame() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_SizingStretchSame") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_SizingStretchSame()
Int ImGui_TableFlags_SizingStretchSame()

Columns default to _WidthStretch with default weights all equal,
unless overriden by TableSetupColumn.

int ImGui_TableFlags_SortMulti()
int ImGui_TableFlags_SortMulti() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_SortMulti") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_SortMulti()
Int ImGui_TableFlags_SortMulti()

Hold shift when clicking headers to sort on multiple column.
TableGetGetSortSpecs may return specs where (SpecsCount > 1).

int ImGui_TableFlags_SortTristate()
int ImGui_TableFlags_SortTristate() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_SortTristate") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_SortTristate()
Int ImGui_TableFlags_SortTristate()

Allow no sorting, disable default sorting.
TableGetColumnSortSpecs may return specs where (SpecsCount == 0).

int ImGui_TableFlags_Sortable()
int ImGui_TableFlags_Sortable() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableFlags_Sortable") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableFlags_Sortable()
Int ImGui_TableFlags_Sortable()

Enable sorting. Call TableNeedSort/TableGetColumnSortSpecs to obtain sort specs.
Also see TableFlags_SortMulti and TableFlags_SortTristate.

int ImGui_TableGetColumnCount(ImGui_Context* ctx)
int ImGui_TableGetColumnCount(ImGui_Context ctx) (requires REAPER 6.24 or later)
int extension_api("ImGui_TableGetColumnCount", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableGetColumnCount(ImGui_Context ctx)
Int ImGui_TableGetColumnCount(ImGui_Context ctx)

Return number of columns (value passed to BeginTable).

int ImGui_TableGetColumnFlags(ImGui_Context* ctx, int* column_nInOptional)
int ImGui_TableGetColumnFlags(ImGui_Context ctx, optional int column_nIn) (requires REAPER 6.24 or later)
int extension_api("ImGui_TableGetColumnFlags", ImGui_Context ctx, optional int column_nIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableGetColumnFlags(ImGui_Context ctx, optional integer column_nIn)
(Int retval, ImGui_Context ctx, Int column_nInOptional) = ImGui_TableGetColumnFlags(ctx, column_nInOptional)

Return column flags so you can query their Enabled/Visible/Sorted/Hovered
status flags. Pass -1 to use current column.

int ImGui_TableGetColumnIndex(ImGui_Context* ctx)
int ImGui_TableGetColumnIndex(ImGui_Context ctx) (requires REAPER 6.24 or later)
int extension_api("ImGui_TableGetColumnIndex", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableGetColumnIndex(ImGui_Context ctx)
Int ImGui_TableGetColumnIndex(ImGui_Context ctx)

Return current column index.

const char* ImGui_TableGetColumnName(ImGui_Context* ctx, int* column_nInOptional)
bool ImGui_TableGetColumnName(#retval, ImGui_Context ctx, optional int column_nIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TableGetColumnName", #retval, ImGui_Context ctx, optional int column_nIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string reaper.ImGui_TableGetColumnName(ImGui_Context ctx, optional integer column_nIn)
(String retval, ImGui_Context ctx, Int column_nInOptional) = ImGui_TableGetColumnName(ctx, column_nInOptional)

Return "" if column didn't have a name declared by TableSetupColumn.
Pass -1 to use current column.

bool ImGui_TableGetColumnSortSpecs(ImGui_Context* ctx, int id, int* column_user_idOut, int* column_indexOut, int* sort_orderOut, int* sort_directionOut)
bool ImGui_TableGetColumnSortSpecs(ImGui_Context ctx, int id, int &column_user_id, int &column_index, int &sort_order, int &sort_direction) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TableGetColumnSortSpecs", ImGui_Context ctx, int id, int &column_user_id, int &column_index, int &sort_order, int &sort_direction) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer column_user_id, integer column_index, integer sort_order, integer sort_direction = reaper.ImGui_TableGetColumnSortSpecs(ImGui_Context ctx, integer id)
(Boolean retval, ImGui_Context ctx, Int id, Int column_user_idOut, Int column_indexOut, Int sort_orderOut, Int sort_directionOut) = ImGui_TableGetColumnSortSpecs(ctx, id, column_user_idOut, column_indexOut, sort_orderOut, sort_directionOut)

Sorting specification for one column of a table.
Call while incrementing 'id' from 0 until false is returned.

- ColumnUserID: User id of the column (if specified by a TableSetupColumn call)
- ColumnIndex: Index of the column
- SortOrder: Index within parent SortSpecs (always stored in order starting
from 0, tables sorted on a single criteria will always have a 0 here)
- SortDirection: SortDirection_Ascending or SortDirection_Descending
(you can use this or SortSign, whichever is more convenient for your sort
function)

See TableNeedSort.

int ImGui_TableGetRowIndex(ImGui_Context* ctx)
int ImGui_TableGetRowIndex(ImGui_Context ctx) (requires REAPER 6.24 or later)
int extension_api("ImGui_TableGetRowIndex", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableGetRowIndex(ImGui_Context ctx)
Int ImGui_TableGetRowIndex(ImGui_Context ctx)

Return current row index.

void ImGui_TableHeader(ImGui_Context* ctx, const char* label)
ImGui_TableHeader(ImGui_Context ctx, "label") (requires REAPER 6.24 or later)
extension_api("ImGui_TableHeader", ImGui_Context ctx, "label") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TableHeader(ImGui_Context ctx, string label)
ImGui_TableHeader(ImGui_Context ctx, String label)

Submit one header cell manually (rarely used). See TableSetupColumn.

void ImGui_TableHeadersRow(ImGui_Context* ctx)
ImGui_TableHeadersRow(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_TableHeadersRow", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TableHeadersRow(ImGui_Context ctx)
ImGui_TableHeadersRow(ImGui_Context ctx)

Submit all headers cells based on data provided to TableSetupColumn +
submit context menu.

bool ImGui_TableNeedSort(ImGui_Context* ctx, bool* has_specsOut)
bool ImGui_TableNeedSort(ImGui_Context ctx, bool &has_specs) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TableNeedSort", ImGui_Context ctx, bool &has_specs) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, boolean has_specs = reaper.ImGui_TableNeedSort(ImGui_Context ctx)
(Boolean retval, ImGui_Context ctx, Boolean has_specsOut) = ImGui_TableNeedSort(ctx, has_specsOut)

Return true once when sorting specs have changed since last call,
or the first time. 'has_specs' is false when not sorting.

See TableGetColumnSortSpecs.

bool ImGui_TableNextColumn(ImGui_Context* ctx)
bool ImGui_TableNextColumn(ImGui_Context ctx) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TableNextColumn", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_TableNextColumn(ImGui_Context ctx)
Boolean ImGui_TableNextColumn(ImGui_Context ctx)

Append into the next column (or first column of next row if currently in
last column). Return true when column is visible.

void ImGui_TableNextRow(ImGui_Context* ctx, int* row_flagsInOptional, double* min_row_heightInOptional)
ImGui_TableNextRow(ImGui_Context ctx, optional int row_flagsIn, optional min_row_heightIn) (requires REAPER 6.24 or later)
extension_api("ImGui_TableNextRow", ImGui_Context ctx, optional int row_flagsIn, optional min_row_heightIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TableNextRow(ImGui_Context ctx, optional integer row_flagsIn, optional number min_row_heightIn)
(ImGui_Context ctx, Int row_flagsInOptional, Float min_row_heightInOptional) = ImGui_TableNextRow(ctx, row_flagsInOptional, min_row_heightInOptional)

Append into the first cell of a new row.

int ImGui_TableRowFlags_Headers()
int ImGui_TableRowFlags_Headers() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableRowFlags_Headers") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableRowFlags_Headers()
Int ImGui_TableRowFlags_Headers()

Identify header row (set default background color + width of its contents
accounted different for auto column width).

int ImGui_TableRowFlags_None()
int ImGui_TableRowFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_TableRowFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TableRowFlags_None()
Int ImGui_TableRowFlags_None()

For TableNextRow.

void ImGui_TableSetBgColor(ImGui_Context* ctx, int target, int color_rgba, int* column_nInOptional)
ImGui_TableSetBgColor(ImGui_Context ctx, int target, int color_rgba, optional int column_nIn) (requires REAPER 6.24 or later)
extension_api("ImGui_TableSetBgColor", ImGui_Context ctx, int target, int color_rgba, optional int column_nIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TableSetBgColor(ImGui_Context ctx, integer target, integer color_rgba, optional integer column_nIn)
(ImGui_Context ctx, Int target, Int color_rgba, Int column_nInOptional) = ImGui_TableSetBgColor(ctx, target, color_rgba, column_nInOptional)

Change the color of a cell, row, or column.
See TableBgTarget_* flags for details.

void ImGui_TableSetColumnEnabled(ImGui_Context* ctx, int column_n, bool v)
ImGui_TableSetColumnEnabled(ImGui_Context ctx, int column_n, bool v) (requires REAPER 6.24 or later)
extension_api("ImGui_TableSetColumnEnabled", ImGui_Context ctx, int column_n, bool v) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TableSetColumnEnabled(ImGui_Context ctx, integer column_n, boolean v)
ImGui_TableSetColumnEnabled(ImGui_Context ctx, Int column_n, Boolean v)

Change user-accessible enabled/disabled state of a column, set to false to
hide the column. Note that end-user can use the context menu to change this
themselves (right-click in headers, or right-click in columns body with
TableFlags_ContextMenuInBody).

- Require table to have the TableFlags_Hideable flag because we are manipulating
user accessible state.
- Request will be applied during next layout, which happens on the first call to
TableNextRow after Begin_Table.
- For the getter you can test
(TableGetColumnFlags() & TableColumnFlags_IsEnabled) != 0.

bool ImGui_TableSetColumnIndex(ImGui_Context* ctx, int column_n)
bool ImGui_TableSetColumnIndex(ImGui_Context ctx, int column_n) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TableSetColumnIndex", ImGui_Context ctx, int column_n) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_TableSetColumnIndex(ImGui_Context ctx, integer column_n)
Boolean ImGui_TableSetColumnIndex(ImGui_Context ctx, Int column_n)

Append into the specified column. Return true when column is visible.

void ImGui_TableSetupColumn(ImGui_Context* ctx, const char* label, int* flagsInOptional, double* init_width_or_weightInOptional, int* user_idInOptional)
ImGui_TableSetupColumn(ImGui_Context ctx, "label", optional int flagsIn, optional init_width_or_weightIn, optional int user_idIn) (requires REAPER 6.24 or later)
extension_api("ImGui_TableSetupColumn", ImGui_Context ctx, "label", optional int flagsIn, optional init_width_or_weightIn, optional int user_idIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TableSetupColumn(ImGui_Context ctx, string label, optional integer flagsIn, optional number init_width_or_weightIn, optional integer user_idIn)
(ImGui_Context ctx, String label, Int flagsInOptional, Float init_width_or_weightInOptional, Int user_idInOptional) = ImGui_TableSetupColumn(ctx, label, flagsInOptional, init_width_or_weightInOptional, user_idInOptional)

Use to specify label, resizing policy, default width/weight, id,
various other flags etc.

void ImGui_TableSetupScrollFreeze(ImGui_Context* ctx, int cols, int rows)
ImGui_TableSetupScrollFreeze(ImGui_Context ctx, int cols, int rows) (requires REAPER 6.24 or later)
extension_api("ImGui_TableSetupScrollFreeze", ImGui_Context ctx, int cols, int rows) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TableSetupScrollFreeze(ImGui_Context ctx, integer cols, integer rows)
ImGui_TableSetupScrollFreeze(ImGui_Context ctx, Int cols, Int rows)

Lock columns/rows so they stay visible when scrolled.

void ImGui_Text(ImGui_Context* ctx, const char* text)
ImGui_Text(ImGui_Context ctx, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_Text", ImGui_Context ctx, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Text(ImGui_Context ctx, string text)
ImGui_Text(ImGui_Context ctx, String text)
void ImGui_TextColored(ImGui_Context* ctx, int col_rgba, const char* text)
ImGui_TextColored(ImGui_Context ctx, int col_rgba, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_TextColored", ImGui_Context ctx, int col_rgba, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TextColored(ImGui_Context ctx, integer col_rgba, string text)
ImGui_TextColored(ImGui_Context ctx, Int col_rgba, String text)

Shortcut for PushStyleColor(Col_Text, color); Text(text); PopStyleColor();

void ImGui_TextDisabled(ImGui_Context* ctx, const char* text)
ImGui_TextDisabled(ImGui_Context ctx, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_TextDisabled", ImGui_Context ctx, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TextDisabled(ImGui_Context ctx, string text)
ImGui_TextDisabled(ImGui_Context ctx, String text)
void ImGui_TextFilter_Clear(ImGui_TextFilter* filter)
ImGui_TextFilter_Clear(ImGui_TextFilter filter) (requires REAPER 6.24 or later)
extension_api("ImGui_TextFilter_Clear", ImGui_TextFilter filter) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TextFilter_Clear(ImGui_TextFilter filter)
ImGui_TextFilter_Clear(ImGui_TextFilter filter)
bool ImGui_TextFilter_Draw(ImGui_TextFilter* filter, ImGui_Context* ctx, const char* labelInOptional, double* widthInOptional)
bool ImGui_TextFilter_Draw(ImGui_TextFilter filter, ImGui_Context ctx, optional "labelIn", optional widthIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TextFilter_Draw", ImGui_TextFilter filter, ImGui_Context ctx, optional "labelIn", optional widthIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_TextFilter_Draw(ImGui_TextFilter filter, ImGui_Context ctx, optional string labelIn, optional number widthIn)
(Boolean retval, ImGui_TextFilter filter, ImGui_Context ctx, String labelInOptional, Float widthInOptional) = ImGui_TextFilter_Draw(filter, ctx, labelInOptional, widthInOptional)

Helper calling InputText+TextFilter_Set

const char* ImGui_TextFilter_Get(ImGui_TextFilter* filter)
bool ImGui_TextFilter_Get(#retval, ImGui_TextFilter filter) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TextFilter_Get", #retval, ImGui_TextFilter filter) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string reaper.ImGui_TextFilter_Get(ImGui_TextFilter filter)
String ImGui_TextFilter_Get(ImGui_TextFilter filter)
bool ImGui_TextFilter_IsActive(ImGui_TextFilter* filter)
bool ImGui_TextFilter_IsActive(ImGui_TextFilter filter) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TextFilter_IsActive", ImGui_TextFilter filter) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_TextFilter_IsActive(ImGui_TextFilter filter)
Boolean ImGui_TextFilter_IsActive(ImGui_TextFilter filter)
bool ImGui_TextFilter_PassFilter(ImGui_TextFilter* filter, const char* text)
bool ImGui_TextFilter_PassFilter(ImGui_TextFilter filter, "text") (requires REAPER 6.24 or later)
bool extension_api("ImGui_TextFilter_PassFilter", ImGui_TextFilter filter, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_TextFilter_PassFilter(ImGui_TextFilter filter, string text)
Boolean ImGui_TextFilter_PassFilter(ImGui_TextFilter filter, String text)
void ImGui_TextFilter_Set(ImGui_TextFilter* filter, const char* filter_text)
ImGui_TextFilter_Set(ImGui_TextFilter filter, "filter_text") (requires REAPER 6.24 or later)
extension_api("ImGui_TextFilter_Set", ImGui_TextFilter filter, "filter_text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TextFilter_Set(ImGui_TextFilter filter, string filter_text)
ImGui_TextFilter_Set(ImGui_TextFilter filter, String filter_text)
void ImGui_TextWrapped(ImGui_Context* ctx, const char* text)
ImGui_TextWrapped(ImGui_Context ctx, "text") (requires REAPER 6.24 or later)
extension_api("ImGui_TextWrapped", ImGui_Context ctx, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TextWrapped(ImGui_Context ctx, string text)
ImGui_TextWrapped(ImGui_Context ctx, String text)

Shortcut for PushTextWrapPos(0.0); Text(text); PopTextWrapPos();.
Note that this won't work on an auto-resizing window if there's no other
widgets to extend the window width, yoy may need to set a size using
SetNextWindowSize.

bool ImGui_TreeNode(ImGui_Context* ctx, const char* label, int* flagsInOptional)
bool ImGui_TreeNode(ImGui_Context ctx, "label", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TreeNode", ImGui_Context ctx, "label", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_TreeNode(ImGui_Context ctx, string label, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Int flagsInOptional) = ImGui_TreeNode(ctx, label, flagsInOptional)

TreeNode functions return true when the node is open, in which case you need
to also call TreePop when you are finished displaying the tree node contents.

bool ImGui_TreeNodeEx(ImGui_Context* ctx, const char* str_id, const char* label, int* flagsInOptional)
bool ImGui_TreeNodeEx(ImGui_Context ctx, "str_id", "label", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_TreeNodeEx", ImGui_Context ctx, "str_id", "label", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_TreeNodeEx(ImGui_Context ctx, string str_id, string label, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String str_id, String label, Int flagsInOptional) = ImGui_TreeNodeEx(ctx, str_id, label, flagsInOptional)

Helper variation to easily decorelate the id from the displayed string.
Read the [FAQ](https://dearimgui.com/faq) about why and how to use ID.
To align arbitrary text at the same level as a TreeNode you can use Bullet.

int ImGui_TreeNodeFlags_AllowItemOverlap()
int ImGui_TreeNodeFlags_AllowItemOverlap() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_AllowItemOverlap") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_AllowItemOverlap()
Int ImGui_TreeNodeFlags_AllowItemOverlap()

Hit testing to allow subsequent widgets to overlap this one.

int ImGui_TreeNodeFlags_Bullet()
int ImGui_TreeNodeFlags_Bullet() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_Bullet") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_Bullet()
Int ImGui_TreeNodeFlags_Bullet()

Display a bullet instead of arrow.

int ImGui_TreeNodeFlags_CollapsingHeader()
int ImGui_TreeNodeFlags_CollapsingHeader() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_CollapsingHeader") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_CollapsingHeader()
Int ImGui_TreeNodeFlags_CollapsingHeader()

TreeNodeFlags_Framed | TreeNodeFlags_NoTreePushOnOpen | TreeNodeFlags_NoAutoOpenOnLog

int ImGui_TreeNodeFlags_DefaultOpen()
int ImGui_TreeNodeFlags_DefaultOpen() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_DefaultOpen") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_DefaultOpen()
Int ImGui_TreeNodeFlags_DefaultOpen()

Default node to be open.

int ImGui_TreeNodeFlags_FramePadding()
int ImGui_TreeNodeFlags_FramePadding() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_FramePadding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_FramePadding()
Int ImGui_TreeNodeFlags_FramePadding()

Use FramePadding (even for an unframed text node) to vertically align text
baseline to regular widget height.
Equivalent to calling AlignTextToFramePadding.

int ImGui_TreeNodeFlags_Framed()
int ImGui_TreeNodeFlags_Framed() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_Framed") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_Framed()
Int ImGui_TreeNodeFlags_Framed()

Draw frame with background (e.g. for CollapsingHeader).

int ImGui_TreeNodeFlags_Leaf()
int ImGui_TreeNodeFlags_Leaf() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_Leaf") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_Leaf()
Int ImGui_TreeNodeFlags_Leaf()

No collapsing, no arrow (use as a convenience for leaf nodes).

int ImGui_TreeNodeFlags_NoAutoOpenOnLog()
int ImGui_TreeNodeFlags_NoAutoOpenOnLog() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_NoAutoOpenOnLog") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_NoAutoOpenOnLog()
Int ImGui_TreeNodeFlags_NoAutoOpenOnLog()

Don't automatically and temporarily open node when Logging is active
(by default logging will automatically open tree nodes).

int ImGui_TreeNodeFlags_NoTreePushOnOpen()
int ImGui_TreeNodeFlags_NoTreePushOnOpen() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_NoTreePushOnOpen") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_NoTreePushOnOpen()
Int ImGui_TreeNodeFlags_NoTreePushOnOpen()

Don't do a TreePush when open (e.g. for CollapsingHeader)
= no extra indent nor pushing on ID stack.

int ImGui_TreeNodeFlags_None()
int ImGui_TreeNodeFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_None()
Int ImGui_TreeNodeFlags_None()
int ImGui_TreeNodeFlags_OpenOnArrow()
int ImGui_TreeNodeFlags_OpenOnArrow() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_OpenOnArrow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_OpenOnArrow()
Int ImGui_TreeNodeFlags_OpenOnArrow()

Only open when clicking on the arrow part.
If TreeNodeFlags_OpenOnDoubleClick is also set, single-click arrow or
double-click all box to open.

int ImGui_TreeNodeFlags_OpenOnDoubleClick()
int ImGui_TreeNodeFlags_OpenOnDoubleClick() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_OpenOnDoubleClick") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_OpenOnDoubleClick()
Int ImGui_TreeNodeFlags_OpenOnDoubleClick()

Need double-click to open node.

int ImGui_TreeNodeFlags_Selected()
int ImGui_TreeNodeFlags_Selected() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_Selected") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_Selected()
Int ImGui_TreeNodeFlags_Selected()

Draw as selected.

int ImGui_TreeNodeFlags_SpanAvailWidth()
int ImGui_TreeNodeFlags_SpanAvailWidth() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_SpanAvailWidth") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_SpanAvailWidth()
Int ImGui_TreeNodeFlags_SpanAvailWidth()

Extend hit box to the right-most edge, even if not framed.
This is not the default in order to allow adding other items on the same line.
In the future we may refactor the hit system to be front-to-back,
allowing natural overlaps and then this can become the default.

int ImGui_TreeNodeFlags_SpanFullWidth()
int ImGui_TreeNodeFlags_SpanFullWidth() (requires REAPER 6.24 or later)
int extension_api("ImGui_TreeNodeFlags_SpanFullWidth") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_TreeNodeFlags_SpanFullWidth()
Int ImGui_TreeNodeFlags_SpanFullWidth()

Extend hit box to the left-most and right-most edges (bypass the indented area).

void ImGui_TreePop(ImGui_Context* ctx)
ImGui_TreePop(ImGui_Context ctx) (requires REAPER 6.24 or later)
extension_api("ImGui_TreePop", ImGui_Context ctx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TreePop(ImGui_Context ctx)
ImGui_TreePop(ImGui_Context ctx)

Unindent()+PopID()

void ImGui_TreePush(ImGui_Context* ctx, const char* str_id)
ImGui_TreePush(ImGui_Context ctx, "str_id") (requires REAPER 6.24 or later)
extension_api("ImGui_TreePush", ImGui_Context ctx, "str_id") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_TreePush(ImGui_Context ctx, string str_id)
ImGui_TreePush(ImGui_Context ctx, String str_id)

Indent()+PushID(). Already called by TreeNode when returning true,
but you can call TreePush/TreePop yourself if desired.

void ImGui_Unindent(ImGui_Context* ctx, double* indent_wInOptional)
ImGui_Unindent(ImGui_Context ctx, optional indent_wIn) (requires REAPER 6.24 or later)
extension_api("ImGui_Unindent", ImGui_Context ctx, optional indent_wIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ImGui_Unindent(ImGui_Context ctx, optional number indent_wIn)
(ImGui_Context ctx, Float indent_wInOptional) = ImGui_Unindent(ctx, indent_wInOptional)

Move content position back to the left, by 'indent_w', or
StyleVar_IndentSpacing if 'indent_w' <= 0

bool ImGui_VSliderDouble(ImGui_Context* ctx, const char* label, double size_w, double size_h, double* vInOut, double v_min, double v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_VSliderDouble(ImGui_Context ctx, "label", size_w, size_h, &v, v_min, v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_VSliderDouble", ImGui_Context ctx, "label", size_w, size_h, &v, v_min, v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number v = reaper.ImGui_VSliderDouble(ImGui_Context ctx, string label, number size_w, number size_h, number v, number v_min, number v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float size_w, Float size_h, Float vInOut, Float v_min, Float v_max, String formatInOptional, Int flagsInOptional) = ImGui_VSliderDouble(ctx, label, size_w, size_h, vInOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_VSliderInt(ImGui_Context* ctx, const char* label, double size_w, double size_h, int* vInOut, int v_min, int v_max, const char* formatInOptional, int* flagsInOptional)
bool ImGui_VSliderInt(ImGui_Context ctx, "label", size_w, size_h, int &v, int v_min, int v_max, optional "formatIn", optional int flagsIn) (requires REAPER 6.24 or later)
bool extension_api("ImGui_VSliderInt", ImGui_Context ctx, "label", size_w, size_h, int &v, int v_min, int v_max, optional "formatIn", optional int flagsIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer v = reaper.ImGui_VSliderInt(ImGui_Context ctx, string label, number size_w, number size_h, integer v, integer v_min, integer v_max, optional string formatIn, optional integer flagsIn)
(Boolean retval, ImGui_Context ctx, String label, Float size_w, Float size_h, Int vInOut, Int v_min, Int v_max, String formatInOptional, Int flagsInOptional) = ImGui_VSliderInt(ctx, label, size_w, size_h, vInOut, v_min, v_max, formatInOptional, flagsInOptional)
bool ImGui_ValidatePtr(void* pointer, const char* type)
bool ImGui_ValidatePtr(void* pointer, "type") (requires REAPER 6.24 or later)
bool extension_api("ImGui_ValidatePtr", void* pointer, "type") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ImGui_ValidatePtr(identifier pointer, string type)
Boolean ImGui_ValidatePtr(void pointer, String type)

Return whether the pointer of the specified type is valid.

Supported types are:

- ImGui_Context*
- ImGui_DrawList*
- ImGui_DrawListSplitter*
- ImGui_Font*
- ImGui_Function*
- ImGui_Image*
- ImGui_ImageSet*
- ImGui_ListClipper*
- ImGui_TextFilter*
- ImGui_Viewport*

void ImGui_Viewport_GetCenter(ImGui_Viewport* viewport, double* xOut, double* yOut)
ImGui_Viewport_GetCenter(ImGui_Viewport viewport, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_Viewport_GetCenter", ImGui_Viewport viewport, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_Viewport_GetCenter(ImGui_Viewport viewport)
(ImGui_Viewport viewport, Float xOut, Float yOut) = ImGui_Viewport_GetCenter(viewport, xOut, yOut)

Center of the viewport.

void ImGui_Viewport_GetPos(ImGui_Viewport* viewport, double* xOut, double* yOut)
ImGui_Viewport_GetPos(ImGui_Viewport viewport, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_Viewport_GetPos", ImGui_Viewport viewport, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_Viewport_GetPos(ImGui_Viewport viewport)
(ImGui_Viewport viewport, Float xOut, Float yOut) = ImGui_Viewport_GetPos(viewport, xOut, yOut)

Main Area: Position of the viewport

void ImGui_Viewport_GetSize(ImGui_Viewport* viewport, double* wOut, double* hOut)
ImGui_Viewport_GetSize(ImGui_Viewport viewport, &w, &h) (requires REAPER 6.24 or later)
extension_api("ImGui_Viewport_GetSize", ImGui_Viewport viewport, &w, &h) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number w, number h = reaper.ImGui_Viewport_GetSize(ImGui_Viewport viewport)
(ImGui_Viewport viewport, Float wOut, Float hOut) = ImGui_Viewport_GetSize(viewport, wOut, hOut)

Main Area: Size of the viewport.

void ImGui_Viewport_GetWorkCenter(ImGui_Viewport* viewport, double* xOut, double* yOut)
ImGui_Viewport_GetWorkCenter(ImGui_Viewport viewport, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_Viewport_GetWorkCenter", ImGui_Viewport viewport, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_Viewport_GetWorkCenter(ImGui_Viewport viewport)
(ImGui_Viewport viewport, Float xOut, Float yOut) = ImGui_Viewport_GetWorkCenter(viewport, xOut, yOut)

Center of the viewport's work area.

void ImGui_Viewport_GetWorkPos(ImGui_Viewport* viewport, double* xOut, double* yOut)
ImGui_Viewport_GetWorkPos(ImGui_Viewport viewport, &x, &y) (requires REAPER 6.24 or later)
extension_api("ImGui_Viewport_GetWorkPos", ImGui_Viewport viewport, &x, &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number x, number y = reaper.ImGui_Viewport_GetWorkPos(ImGui_Viewport viewport)
(ImGui_Viewport viewport, Float xOut, Float yOut) = ImGui_Viewport_GetWorkPos(viewport, xOut, yOut)

>= Viewport_GetPos

void ImGui_Viewport_GetWorkSize(ImGui_Viewport* viewport, double* wOut, double* hOut)
ImGui_Viewport_GetWorkSize(ImGui_Viewport viewport, &w, &h) (requires REAPER 6.24 or later)
extension_api("ImGui_Viewport_GetWorkSize", ImGui_Viewport viewport, &w, &h) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number w, number h = reaper.ImGui_Viewport_GetWorkSize(ImGui_Viewport viewport)
(ImGui_Viewport viewport, Float wOut, Float hOut) = ImGui_Viewport_GetWorkSize(viewport, wOut, hOut)

<= Viewport_GetSize

int ImGui_WindowFlags_AlwaysAutoResize()
int ImGui_WindowFlags_AlwaysAutoResize() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_AlwaysAutoResize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_AlwaysAutoResize()
Int ImGui_WindowFlags_AlwaysAutoResize()

Resize every window to its content every frame.

int ImGui_WindowFlags_AlwaysHorizontalScrollbar()
int ImGui_WindowFlags_AlwaysHorizontalScrollbar() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_AlwaysHorizontalScrollbar") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_AlwaysHorizontalScrollbar()
Int ImGui_WindowFlags_AlwaysHorizontalScrollbar()

Always show horizontal scrollbar (even if ContentSize.x < Size.x).

int ImGui_WindowFlags_AlwaysUseWindowPadding()
int ImGui_WindowFlags_AlwaysUseWindowPadding() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_AlwaysUseWindowPadding") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_AlwaysUseWindowPadding()
Int ImGui_WindowFlags_AlwaysUseWindowPadding()

Ensure child windows without border uses StyleVar_WindowPadding
(ignored by default for non-bordered child windows, because more convenient).

int ImGui_WindowFlags_AlwaysVerticalScrollbar()
int ImGui_WindowFlags_AlwaysVerticalScrollbar() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_AlwaysVerticalScrollbar") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_AlwaysVerticalScrollbar()
Int ImGui_WindowFlags_AlwaysVerticalScrollbar()

Always show vertical scrollbar (even if ContentSize.y < Size.y).

int ImGui_WindowFlags_HorizontalScrollbar()
int ImGui_WindowFlags_HorizontalScrollbar() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_HorizontalScrollbar") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_HorizontalScrollbar()
Int ImGui_WindowFlags_HorizontalScrollbar()

Allow horizontal scrollbar to appear (off by default).
You may use SetNextWindowContentSize(width, 0.0) prior to calling Begin() to
specify width. Read code in the demo's "Horizontal Scrolling" section.

int ImGui_WindowFlags_MenuBar()
int ImGui_WindowFlags_MenuBar() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_MenuBar") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_MenuBar()
Int ImGui_WindowFlags_MenuBar()

Has a menu-bar.

int ImGui_WindowFlags_NoBackground()
int ImGui_WindowFlags_NoBackground() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoBackground") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoBackground()
Int ImGui_WindowFlags_NoBackground()

Disable drawing background color (WindowBg, etc.) and outside border.
Similar as using SetNextWindowBgAlpha(0.0).

int ImGui_WindowFlags_NoCollapse()
int ImGui_WindowFlags_NoCollapse() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoCollapse") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoCollapse()
Int ImGui_WindowFlags_NoCollapse()

Disable user collapsing window by double-clicking on it.
Also referred to as Window Menu Button (e.g. within a docking node).

int ImGui_WindowFlags_NoDecoration()
int ImGui_WindowFlags_NoDecoration() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoDecoration") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoDecoration()
Int ImGui_WindowFlags_NoDecoration()

WindowFlags_NoTitleBar | WindowFlags_NoResize | WindowFlags_NoScrollbar |
WindowFlags_NoCollapse

int ImGui_WindowFlags_NoDocking()
int ImGui_WindowFlags_NoDocking() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoDocking") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoDocking()
Int ImGui_WindowFlags_NoDocking()

Disable docking of this window.

int ImGui_WindowFlags_NoFocusOnAppearing()
int ImGui_WindowFlags_NoFocusOnAppearing() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoFocusOnAppearing") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoFocusOnAppearing()
Int ImGui_WindowFlags_NoFocusOnAppearing()

Disable taking focus when transitioning from hidden to visible state.

int ImGui_WindowFlags_NoInputs()
int ImGui_WindowFlags_NoInputs() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoInputs") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoInputs()
Int ImGui_WindowFlags_NoInputs()

WindowFlags_NoMouseInputs | WindowFlags_NoNavInputs | WindowFlags_NoNavFocus

int ImGui_WindowFlags_NoMouseInputs()
int ImGui_WindowFlags_NoMouseInputs() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoMouseInputs") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoMouseInputs()
Int ImGui_WindowFlags_NoMouseInputs()

Disable catching mouse, hovering test with pass through.

int ImGui_WindowFlags_NoMove()
int ImGui_WindowFlags_NoMove() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoMove") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoMove()
Int ImGui_WindowFlags_NoMove()

Disable user moving the window.

int ImGui_WindowFlags_NoNav()
int ImGui_WindowFlags_NoNav() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoNav") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoNav()
Int ImGui_WindowFlags_NoNav()

WindowFlags_NoNavInputs | WindowFlags_NoNavFocus

int ImGui_WindowFlags_NoNavFocus()
int ImGui_WindowFlags_NoNavFocus() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoNavFocus") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoNavFocus()
Int ImGui_WindowFlags_NoNavFocus()

No focusing toward this window with gamepad/keyboard navigation
(e.g. skipped by CTRL+TAB).

int ImGui_WindowFlags_NoNavInputs()
int ImGui_WindowFlags_NoNavInputs() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoNavInputs") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoNavInputs()
Int ImGui_WindowFlags_NoNavInputs()

No gamepad/keyboard navigation within the window.

int ImGui_WindowFlags_NoResize()
int ImGui_WindowFlags_NoResize() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoResize") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoResize()
Int ImGui_WindowFlags_NoResize()

Disable user resizing with the lower-right grip.

int ImGui_WindowFlags_NoSavedSettings()
int ImGui_WindowFlags_NoSavedSettings() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoSavedSettings") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoSavedSettings()
Int ImGui_WindowFlags_NoSavedSettings()

Never load/save settings in .ini file.

int ImGui_WindowFlags_NoScrollWithMouse()
int ImGui_WindowFlags_NoScrollWithMouse() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoScrollWithMouse") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoScrollWithMouse()
Int ImGui_WindowFlags_NoScrollWithMouse()

Disable user vertically scrolling with mouse wheel.
On child window, mouse wheel will be forwarded to the parent unless
NoScrollbar is also set.

int ImGui_WindowFlags_NoScrollbar()
int ImGui_WindowFlags_NoScrollbar() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoScrollbar") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoScrollbar()
Int ImGui_WindowFlags_NoScrollbar()

Disable scrollbars (window can still scroll with mouse or programmatically).

int ImGui_WindowFlags_NoTitleBar()
int ImGui_WindowFlags_NoTitleBar() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_NoTitleBar") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_NoTitleBar()
Int ImGui_WindowFlags_NoTitleBar()

Disable title-bar.

int ImGui_WindowFlags_None()
int ImGui_WindowFlags_None() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_None") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_None()
Int ImGui_WindowFlags_None()

Default flag.

int ImGui_WindowFlags_TopMost()
int ImGui_WindowFlags_TopMost() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_TopMost") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_TopMost()
Int ImGui_WindowFlags_TopMost()

Show the window above all non-topmost windows.

int ImGui_WindowFlags_UnsavedDocument()
int ImGui_WindowFlags_UnsavedDocument() (requires REAPER 6.24 or later)
int extension_api("ImGui_WindowFlags_UnsavedDocument") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.ImGui_WindowFlags_UnsavedDocument()
Int ImGui_WindowFlags_UnsavedDocument()

Display a dot next to the title. When used in a tab/docking context,
tab is selected when clicking the X + closure is not assumed
(will wait for user to stop submitting the tab).
Otherwise closure is assumed when pressing the X,
so if you keep submitting the tab may reappear at end of tab bar.

int JS_Actions_CountShortcuts(int section, int cmdID)
int JS_Actions_CountShortcuts(int section, int cmdID) (requires REAPER 6.24 or later)
int extension_api("JS_Actions_CountShortcuts", int section, int cmdID) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Actions_CountShortcuts(integer section, integer cmdID)
Int JS_Actions_CountShortcuts(Int section, Int cmdID)

Section:
0 = Main, 100 = Main (alt recording), 32060 = MIDI Editor, 32061 = MIDI Event List Editor, 32062 = MIDI Inline Editor, 32063 = Media Explorer.

bool JS_Actions_DeleteShortcut(int section, int cmdID, int shortcutidx)
bool JS_Actions_DeleteShortcut(int section, int cmdID, int shortcutidx) (requires REAPER 6.24 or later)
bool extension_api("JS_Actions_DeleteShortcut", int section, int cmdID, int shortcutidx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Actions_DeleteShortcut(integer section, integer cmdID, integer shortcutidx)
Boolean JS_Actions_DeleteShortcut(Int section, Int cmdID, Int shortcutidx)

Section:
0 = Main, 100 = Main (alt recording), 32060 = MIDI Editor, 32061 = MIDI Event List Editor, 32062 = MIDI Inline Editor, 32063 = Media Explorer.

bool JS_Actions_DoShortcutDialog(int section, int cmdID, int shortcutidx)
bool JS_Actions_DoShortcutDialog(int section, int cmdID, int shortcutidx) (requires REAPER 6.24 or later)
bool extension_api("JS_Actions_DoShortcutDialog", int section, int cmdID, int shortcutidx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Actions_DoShortcutDialog(integer section, integer cmdID, integer shortcutidx)
Boolean JS_Actions_DoShortcutDialog(Int section, Int cmdID, Int shortcutidx)

Section:
0 = Main, 100 = Main (alt recording), 32060 = MIDI Editor, 32061 = MIDI Event List Editor, 32062 = MIDI Inline Editor, 32063 = Media Explorer.

If the shortcut index is higher than the current number of shortcuts, it will add a new shortcut.

bool JS_Actions_GetShortcutDesc(int section, int cmdID, int shortcutidx, char* descOut, int descOut_sz)
bool JS_Actions_GetShortcutDesc(int section, int cmdID, int shortcutidx, #desc) (requires REAPER 6.24 or later)
bool extension_api("JS_Actions_GetShortcutDesc", int section, int cmdID, int shortcutidx, #desc) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string desc = reaper.JS_Actions_GetShortcutDesc(integer section, integer cmdID, integer shortcutidx)
(Boolean retval, Int section, Int cmdID, Int shortcutidx, String descOut, Int descOut_sz) = JS_Actions_GetShortcutDesc(section, cmdID, shortcutidx, descOut, descOut_sz)

Section:
0 = Main, 100 = Main (alt recording), 32060 = MIDI Editor, 32061 = MIDI Event List Editor, 32062 = MIDI Inline Editor, 32063 = Media Explorer.

void JS_Byte(void* pointer, int offset, int* byteOut)
JS_Byte(void* pointer, int offset, int &byte) (requires REAPER 6.24 or later)
extension_api("JS_Byte", void* pointer, int offset, int &byte) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer byte = reaper.JS_Byte(identifier pointer, integer offset)
(void pointer, Int offset, Int byteOut) = JS_Byte(pointer, offset, byteOut)

Returns the unsigned byte at address[offset]. Offset is added as steps of 1 byte each.

int JS_Composite(void* windowHWND, int dstx, int dsty, int dstw, int dsth, void* sysBitmap, int srcx, int srcy, int srcw, int srch, bool* autoUpdateOptional)
int JS_Composite(void* windowHWND, int dstx, int dsty, int dstw, int dsth, void* sysBitmap, int srcx, int srcy, int srcw, int srch, unsupported autoUpdateOptional) (requires REAPER 6.24 or later)
int extension_api("JS_Composite", void* windowHWND, int dstx, int dsty, int dstw, int dsth, void* sysBitmap, int srcx, int srcy, int srcw, int srch, unsupported autoUpdateOptional) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Composite(identifier windowHWND, integer dstx, integer dsty, integer dstw, integer dsth, identifier sysBitmap, integer srcx, integer srcy, integer srcw, integer srch, unsupported autoUpdate)
(Int retval, void windowHWND, Int dstx, Int dsty, Int dstw, Int dsth, void sysBitmap, Int srcx, Int srcy, Int srcw, Int srch, Boolean autoUpdateOptional) = JS_Composite(windowHWND, dstx, dsty, dstw, dsth, sysBitmap, srcx, srcy, srcw, srch, autoUpdateOptional)

Composites a LICE bitmap with a REAPER window. Each time that the window is re-drawn, the bitmap will be blitted over the window's client area (with per-pixel alpha blending).

* If dstw or dsth is -1, the bitmap will be stretched to fill the width or height of the window, respectively.

* autoUpdate is an optional parameter that is false by default. If true, JS_Composite will automatically invalidate and re-draw the part of the window that covers the current position of the bitmap, and if the bitmap is being moved, also the previous position. (If only one or a handful of bitmaps are being moved across the screen, autoUpdate should result in smoother animation on WindowsOS; if numerous bitmaps are spread over the entire window, it may be faster to disable autoUpdate and instead call JS_Window_InvalidateRect explicitly once all bitmaps have been moved.)

* InvalidateRect should also be called whenever the contents of the bitmap contents have been changed, but not the position, to trigger a window update.

* On WindowsOS, the key to reducing flickering is to slow down the frequency at which the window is re-drawn. InvalidateRect should only be called when absolutely necessary, preferably not more than 20 times per second. (Also refer to the JS_Composite_Delay function.)

* On WindowsOS, flickering can further be reduced by keeping the invalidated area as small as possible, covering only the bitmaps that have been edited or moved. However, if numerous bitmaps are spread over the entire window, it may be faster to simply invalidate the entire client area.

* This function should not be applied directly to top-level windows, but rather to child windows.

* Some classes of UI elements, particularly buttons, do not take kindly to being composited, and may crash REAPER.

* On WindowsOS, GDI blitting does not perform alpha multiplication of the source bitmap. For proper color rendering, a separate pre-multiplication step is therefore required, using either LICE_Blit or LICE_ProcessRect.

Returns:
1 if successful, otherwise -1 = windowHWND is not a window, -3 = Could not obtain the original window process, -4 = sysBitmap is not a LICE bitmap, -5 = sysBitmap is not a system bitmap, -6 = Could not obtain the window HDC, -7 = Error when subclassing to new window process.

int JS_Composite_Delay(void* windowHWND, double minTime, double maxTime, int numBitmapsWhenMax, double* prevMinTimeOut, double* prevMaxTimeOut, int* prevBitmapsOut)
int JS_Composite_Delay(void* windowHWND, minTime, maxTime, int numBitmapsWhenMax, &prevMinTime, &prevMaxTime, int &prevBitmaps) (requires REAPER 6.24 or later)
int extension_api("JS_Composite_Delay", void* windowHWND, minTime, maxTime, int numBitmapsWhenMax, &prevMinTime, &prevMaxTime, int &prevBitmaps) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, number prevMinTime, number prevMaxTime, integer prevBitmaps = reaper.JS_Composite_Delay(identifier windowHWND, number minTime, number maxTime, integer numBitmapsWhenMax)
(Int retval, void windowHWND, Float minTime, Float maxTime, Int numBitmapsWhenMax, Float prevMinTimeOut, Float prevMaxTimeOut, Int prevBitmapsOut) = JS_Composite_Delay(windowHWND, minTime, maxTime, numBitmapsWhenMax, prevMinTimeOut, prevMaxTimeOut, prevBitmapsOut)

On WindowsOS, flickering of composited images can be improved considerably by slowing the refresh rate of the window. The optimal refresh rate may depend on the number of composited bitmaps.

minTime is the minimum refresh delay, in seconds, when only one bitmap is composited onto the window. The delay time will increase linearly with the number of bitmaps, up to a maximum of maxTime when numBitmapsWhenMax is reached.

If both minTime and maxTime are 0, all delay settings for the window are cleared.

Returns:
* retval = 1 if successful, 0 if arguments are invalid (i.e. if maxTime < minTime, or maxBitmaps < 1).
* If delay times have not previously been set for this window, prev time values are 0.

int JS_Composite_ListBitmaps(void* windowHWND, char* listOutNeedBig, int listOutNeedBig_sz)
int JS_Composite_ListBitmaps(void* windowHWND, #list) (requires REAPER 6.24 or later)
int extension_api("JS_Composite_ListBitmaps", void* windowHWND, #list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string list = reaper.JS_Composite_ListBitmaps(identifier windowHWND)
(Int retval, void windowHWND, String listOutNeedBig, Int listOutNeedBig_sz) = JS_Composite_ListBitmaps(windowHWND, listOutNeedBig, listOutNeedBig_sz)

Returns all bitmaps composited to the given window.

The list is formatted as a comma-separated string of hexadecimal values, each representing a LICE_IBitmap* pointer.

retval is the number of linked bitmaps found, or negative if an error occured.

int JS_Dialog_BrowseForFolder(const char* caption, const char* initialFolder, char* folderOutNeedBig, int folderOutNeedBig_sz)
int JS_Dialog_BrowseForFolder("caption", "initialFolder", #folder) (requires REAPER 6.24 or later)
int extension_api("JS_Dialog_BrowseForFolder", "caption", "initialFolder", #folder) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string folder = reaper.JS_Dialog_BrowseForFolder(string caption, string initialFolder)
(Int retval, String caption, String initialFolder, String folderOutNeedBig, Int folderOutNeedBig_sz) = JS_Dialog_BrowseForFolder(caption, initialFolder, folderOutNeedBig, folderOutNeedBig_sz)

retval is 1 if a file was selected, 0 if the user cancelled the dialog, and -1 if an error occurred.

int JS_Dialog_BrowseForOpenFiles(const char* windowTitle, const char* initialFolder, const char* initialFile, const char* extensionList, bool allowMultiple, char* fileNamesOutNeedBig, int fileNamesOutNeedBig_sz)
int JS_Dialog_BrowseForOpenFiles("windowTitle", "initialFolder", "initialFile", "extensionList", bool allowMultiple, #fileNames) (requires REAPER 6.24 or later)
int extension_api("JS_Dialog_BrowseForOpenFiles", "windowTitle", "initialFolder", "initialFile", "extensionList", bool allowMultiple, #fileNames) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string fileNames = reaper.JS_Dialog_BrowseForOpenFiles(string windowTitle, string initialFolder, string initialFile, string extensionList, boolean allowMultiple)
(Int retval, String windowTitle, String initialFolder, String initialFile, String extensionList, Boolean allowMultiple, String fileNamesOutNeedBig, Int fileNamesOutNeedBig_sz) = JS_Dialog_BrowseForOpenFiles(windowTitle, initialFolder, initialFile, extensionList, allowMultiple, fileNamesOutNeedBig, fileNamesOutNeedBig_sz)

If allowMultiple is true, multiple files may be selected. The returned string is \0-separated, with the first substring containing the folder path and subsequent substrings containing the file names.
* On macOS, the first substring may be empty, and each file name will then contain its entire path.
* This function only allows selection of existing files, and does not allow creation of new files.

extensionList is a string containing pairs of \0-terminated substrings. The last substring must be terminated by two \0 characters. Each pair defines one filter pattern:
* The first substring in each pair describes the filter in user-readable form (for example, "Lua script files (*.lua)") and will be displayed in the dialog box.
* The second substring specifies the filter that the operating system must use to search for the files (for example, "*.txt"; the wildcard should not be omitted). To specify multiple extensions for a single display string, use a semicolon to separate the patterns (for example, "*.lua;*.eel").

An example of an extensionList string:
"ReaScript files\0*.lua;*.eel\0Lua files (.lua)\0*.lua\0EEL files (.eel)\0*.eel\0\0".

On macOS, file dialogs do not accept empty extensionLists, nor wildcard extensions (such as "All files\0*.*\0\0"), so each acceptable extension must be listed explicitly. On Linux and Windows, wildcard extensions are acceptable, and if the extensionList string is empty, the dialog will display a default "All files (*.*)" filter.

retval is 1 if one or more files were selected, 0 if the user cancelled the dialog, or negative if an error occurred.

Displaying \0-separated strings:
* REAPER's IDE and ShowConsoleMsg only display strings up to the first \0 byte. If multiple files were selected, only the first substring containing the path will be displayed. This is not a problem for Lua or EEL, which can access the full string beyond the first \0 byte as usual.

int JS_Dialog_BrowseForSaveFile(const char* windowTitle, const char* initialFolder, const char* initialFile, const char* extensionList, char* fileNameOutNeedBig, int fileNameOutNeedBig_sz)
int JS_Dialog_BrowseForSaveFile("windowTitle", "initialFolder", "initialFile", "extensionList", #fileName) (requires REAPER 6.24 or later)
int extension_api("JS_Dialog_BrowseForSaveFile", "windowTitle", "initialFolder", "initialFile", "extensionList", #fileName) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string fileName = reaper.JS_Dialog_BrowseForSaveFile(string windowTitle, string initialFolder, string initialFile, string extensionList)
(Int retval, String windowTitle, String initialFolder, String initialFile, String extensionList, String fileNameOutNeedBig, Int fileNameOutNeedBig_sz) = JS_Dialog_BrowseForSaveFile(windowTitle, initialFolder, initialFile, extensionList, fileNameOutNeedBig, fileNameOutNeedBig_sz)

retval is 1 if a file was selected, 0 if the user cancelled the dialog, or negative if an error occurred.

extensionList is as described for JS_Dialog_BrowseForOpenFiles.

void JS_Double(void* pointer, int offset, double* doubleOut)
JS_Double(void* pointer, int offset, &double) (requires REAPER 6.24 or later)
extension_api("JS_Double", void* pointer, int offset, &double) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number double = reaper.JS_Double(identifier pointer, integer offset)
(void pointer, Int offset, Float doubleOut) = JS_Double(pointer, offset, doubleOut)

Returns the 8-byte floating point value at address[offset]. Offset is added as steps of 8 bytes each.

int JS_File_Stat(const char* filePath, double* sizeOut, char* accessedTimeOut, char* modifiedTimeOut, char* cTimeOut, int* deviceIDOut, int* deviceSpecialIDOut, int* inodeOut, int* modeOut, int* numLinksOut, int* ownerUserIDOut, int* ownerGroupIDOut)
int JS_File_Stat("filePath", &size, #accessedTime, #modifiedTime, #cTime, int &deviceID, int &deviceSpecialID, int &inode, int &mode, int &numLinks, int &ownerUserID, int &ownerGroupID) (requires REAPER 6.24 or later)
int extension_api("JS_File_Stat", "filePath", &size, #accessedTime, #modifiedTime, #cTime, int &deviceID, int &deviceSpecialID, int &inode, int &mode, int &numLinks, int &ownerUserID, int &ownerGroupID) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, number size, string accessedTime, string modifiedTime, string cTime, integer deviceID, integer deviceSpecialID, integer inode, integer mode, integer numLinks, integer ownerUserID, integer ownerGroupID = reaper.JS_File_Stat(string filePath)
(Int retval, String filePath, Float sizeOut, String accessedTimeOut, String modifiedTimeOut, String cTimeOut, Int deviceIDOut, Int deviceSpecialIDOut, Int inodeOut, Int modeOut, Int numLinksOut, Int ownerUserIDOut, Int ownerGroupIDOut) = JS_File_Stat(filePath, sizeOut, accessedTimeOut, modifiedTimeOut, cTimeOut, deviceIDOut, deviceSpecialIDOut, inodeOut, modeOut, numLinksOut, ownerUserIDOut, ownerGroupIDOut)

Returns information about a file.

cTime is not implemented on all systems. If it does return a time, the value may differ depending on the OS: on WindowsOS, it may refer to the time that the file was either created or copied, whereas on Linux and macOS, it may refer to the time of last status change.

retval is 0 if successful, negative if not.

void JS_GDI_Blit(void* destHDC, int dstx, int dsty, void* sourceHDC, int srcx, int srxy, int width, int height, const char* modeOptional)
JS_GDI_Blit(void* destHDC, int dstx, int dsty, void* sourceHDC, int srcx, int srxy, int width, int height, optional "mode") (requires REAPER 6.24 or later)
extension_api("JS_GDI_Blit", void* destHDC, int dstx, int dsty, void* sourceHDC, int srcx, int srxy, int width, int height, optional "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_Blit(identifier destHDC, integer dstx, integer dsty, identifier sourceHDC, integer srcx, integer srxy, integer width, integer height, optional string mode)
JS_GDI_Blit(void destHDC, Int dstx, Int dsty, void sourceHDC, Int srcx, Int srxy, Int width, Int height, String modeOptional)

Blits between two device contexts, which may include LICE "system bitmaps".

mode: Optional parameter. "SRCCOPY" by default, or specify "ALPHA" to enable per-pixel alpha blending.

WARNING: On WindowsOS, GDI_Blit does not perform alpha multiplication of the source bitmap. For proper color rendering, a separate pre-multiplication step is therefore required, using either LICE_Blit or LICE_ProcessRect.

void* JS_GDI_CreateFillBrush(int color)
void* JS_GDI_CreateFillBrush(int color) (requires REAPER 6.24 or later)
void* extension_api("JS_GDI_CreateFillBrush", int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_GDI_CreateFillBrush(integer color)
void JS_GDI_CreateFillBrush(Int color)
void* JS_GDI_CreateFont(int height, int weight, int angle, bool italic, bool underline, bool strikeOut, const char* fontName)
void* JS_GDI_CreateFont(int height, int weight, int angle, bool italic, bool underline, bool strike, "fontName") (requires REAPER 6.24 or later)
void* extension_api("JS_GDI_CreateFont", int height, int weight, int angle, bool italic, bool underline, bool strike, "fontName") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_GDI_CreateFont(integer height, integer weight, integer angle, boolean italic, boolean underline, boolean strike, string fontName)
void JS_GDI_CreateFont(Int height, Int weight, Int angle, Boolean italic, Boolean underline, Boolean strikeOut, String fontName)

Parameters:
* weight: 0 - 1000, with 0 = auto, 400 = normal and 700 = bold.
* angle: the angle, in tenths of degrees, between the text and the x-axis of the device.
* fontName: If empty string "", uses first font that matches the other specified attributes.

Note: Text color must be set separately.

void* JS_GDI_CreatePen(int width, int color)
void* JS_GDI_CreatePen(int width, int color) (requires REAPER 6.24 or later)
void* extension_api("JS_GDI_CreatePen", int width, int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_GDI_CreatePen(integer width, integer color)
void JS_GDI_CreatePen(Int width, Int color)
void JS_GDI_DeleteObject(void* GDIObject)
JS_GDI_DeleteObject(void* GDIObject) (requires REAPER 6.24 or later)
extension_api("JS_GDI_DeleteObject", void* GDIObject) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_DeleteObject(identifier GDIObject)
JS_GDI_DeleteObject(void GDIObject)
int JS_GDI_DrawText(void* deviceHDC, const char* text, int len, int left, int top, int right, int bottom, const char* align))
int JS_GDI_DrawText(void* deviceHDC, "text", int len, int left, int top, int right, int bottom, "align)") (requires REAPER 6.24 or later)
int extension_api("JS_GDI_DrawText", void* deviceHDC, "text", int len, int left, int top, int right, int bottom, "align)") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_GDI_DrawText(identifier deviceHDC, string text, integer len, integer left, integer top, integer right, integer bottom, string align))
Int JS_GDI_DrawText(void deviceHDC, String text, Int len, Int left, Int top, Int right, Int bottom, String align))

Parameters:
* align: Combination of: "TOP", "VCENTER", "LEFT", "HCENTER", "RIGHT", "BOTTOM", "WORDBREAK", "SINGLELINE", "NOCLIP", "CALCRECT", "NOPREFIX" or "ELLIPSIS"

void JS_GDI_FillEllipse(void* deviceHDC, int left, int top, int right, int bottom)
JS_GDI_FillEllipse(void* deviceHDC, int left, int top, int right, int bottom) (requires REAPER 6.24 or later)
extension_api("JS_GDI_FillEllipse", void* deviceHDC, int left, int top, int right, int bottom) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_FillEllipse(identifier deviceHDC, integer left, integer top, integer right, integer bottom)
JS_GDI_FillEllipse(void deviceHDC, Int left, Int top, Int right, Int bottom)
void JS_GDI_FillPolygon(void* deviceHDC, const char* packedX, const char* packedY, int numPoints)
JS_GDI_FillPolygon(void* deviceHDC, "packedX", "packedY", int numPoints) (requires REAPER 6.24 or later)
extension_api("JS_GDI_FillPolygon", void* deviceHDC, "packedX", "packedY", int numPoints) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_FillPolygon(identifier deviceHDC, string packedX, string packedY, integer numPoints)
JS_GDI_FillPolygon(void deviceHDC, String packedX, String packedY, Int numPoints)

packedX and packedY are strings of points, each packed as "<i4".

void JS_GDI_FillRect(void* deviceHDC, int left, int top, int right, int bottom)
JS_GDI_FillRect(void* deviceHDC, int left, int top, int right, int bottom) (requires REAPER 6.24 or later)
extension_api("JS_GDI_FillRect", void* deviceHDC, int left, int top, int right, int bottom) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_FillRect(identifier deviceHDC, integer left, integer top, integer right, integer bottom)
JS_GDI_FillRect(void deviceHDC, Int left, Int top, Int right, Int bottom)
void JS_GDI_FillRoundRect(void* deviceHDC, int left, int top, int right, int bottom, int xrnd, int yrnd)
JS_GDI_FillRoundRect(void* deviceHDC, int left, int top, int right, int bottom, int xrnd, int yrnd) (requires REAPER 6.24 or later)
extension_api("JS_GDI_FillRoundRect", void* deviceHDC, int left, int top, int right, int bottom, int xrnd, int yrnd) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_FillRoundRect(identifier deviceHDC, integer left, integer top, integer right, integer bottom, integer xrnd, integer yrnd)
JS_GDI_FillRoundRect(void deviceHDC, Int left, Int top, Int right, Int bottom, Int xrnd, Int yrnd)
void* JS_GDI_GetClientDC(void* windowHWND)
void* JS_GDI_GetClientDC(void* windowHWND) (requires REAPER 6.24 or later)
void* extension_api("JS_GDI_GetClientDC", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_GDI_GetClientDC(identifier windowHWND)
void JS_GDI_GetClientDC(void windowHWND)

Returns the device context for the client area of the specified window.

void* JS_GDI_GetScreenDC()
void* JS_GDI_GetScreenDC() (requires REAPER 6.24 or later)
void* extension_api("JS_GDI_GetScreenDC") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_GDI_GetScreenDC()
void JS_GDI_GetScreenDC()

Returns a device context for the entire screen.

WARNING: Only available on Windows, not Linux or macOS.

int JS_GDI_GetSysColor(const char* GUIElement)
int JS_GDI_GetSysColor("GUIElement") (requires REAPER 6.24 or later)
int extension_api("JS_GDI_GetSysColor", "GUIElement") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_GDI_GetSysColor(string GUIElement)
Int JS_GDI_GetSysColor(String GUIElement)
int JS_GDI_GetTextColor(void* deviceHDC)
int JS_GDI_GetTextColor(void* deviceHDC) (requires REAPER 6.24 or later)
int extension_api("JS_GDI_GetTextColor", void* deviceHDC) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_GDI_GetTextColor(identifier deviceHDC)
Int JS_GDI_GetTextColor(void deviceHDC)
void* JS_GDI_GetWindowDC(void* windowHWND)
void* JS_GDI_GetWindowDC(void* windowHWND) (requires REAPER 6.24 or later)
void* extension_api("JS_GDI_GetWindowDC", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_GDI_GetWindowDC(identifier windowHWND)
void JS_GDI_GetWindowDC(void windowHWND)

Returns the device context for the entire window, including title bar and frame.

void JS_GDI_Line(void* deviceHDC, int x1, int y1, int x2, int y2)
JS_GDI_Line(void* deviceHDC, int x1, int y1, int x2, int y2) (requires REAPER 6.24 or later)
extension_api("JS_GDI_Line", void* deviceHDC, int x1, int y1, int x2, int y2) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_Line(identifier deviceHDC, integer x1, integer y1, integer x2, integer y2)
JS_GDI_Line(void deviceHDC, Int x1, Int y1, Int x2, Int y2)
void JS_GDI_Polyline(void* deviceHDC, const char* packedX, const char* packedY, int numPoints)
JS_GDI_Polyline(void* deviceHDC, "packedX", "packedY", int numPoints) (requires REAPER 6.24 or later)
extension_api("JS_GDI_Polyline", void* deviceHDC, "packedX", "packedY", int numPoints) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_Polyline(identifier deviceHDC, string packedX, string packedY, integer numPoints)
JS_GDI_Polyline(void deviceHDC, String packedX, String packedY, Int numPoints)

packedX and packedY are strings of points, each packed as "<i4".

int JS_GDI_ReleaseDC(void* deviceHDC, void* windowHWNDOptional)
int JS_GDI_ReleaseDC(void* deviceHDC, void* windowHWND) (requires REAPER 6.24 or later)
int extension_api("JS_GDI_ReleaseDC", void* deviceHDC, void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_GDI_ReleaseDC(identifier deviceHDC, identifier windowHWND)
Int JS_GDI_ReleaseDC(void deviceHDC, void windowHWNDOptional)

To release a window HDC, both arguments must be supplied: the HWND as well as the HDC. To release a screen DC, only the HDC needs to be supplied.

For compatibility with previous versions, the HWND and HDC can be supplied in any order.

NOTE: Any GDI HDC should be released immediately after drawing, and deferred scripts should get and release new DCs in each cycle.

void* JS_GDI_SelectObject(void* deviceHDC, void* GDIObject)
void* JS_GDI_SelectObject(void* deviceHDC, void* GDIObject) (requires REAPER 6.24 or later)
void* extension_api("JS_GDI_SelectObject", void* deviceHDC, void* GDIObject) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_GDI_SelectObject(identifier deviceHDC, identifier GDIObject)
void JS_GDI_SelectObject(void deviceHDC, void GDIObject)

Activates a font, pen, or fill brush for subsequent drawing in the specified device context.

void JS_GDI_SetPixel(void* deviceHDC, int x, int y, int color)
JS_GDI_SetPixel(void* deviceHDC, int x, int y, int color) (requires REAPER 6.24 or later)
extension_api("JS_GDI_SetPixel", void* deviceHDC, int x, int y, int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_SetPixel(identifier deviceHDC, integer x, integer y, integer color)
JS_GDI_SetPixel(void deviceHDC, Int x, Int y, Int color)
void JS_GDI_SetTextBkColor(void* deviceHDC, int color)
JS_GDI_SetTextBkColor(void* deviceHDC, int color) (requires REAPER 6.24 or later)
extension_api("JS_GDI_SetTextBkColor", void* deviceHDC, int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_SetTextBkColor(identifier deviceHDC, integer color)
JS_GDI_SetTextBkColor(void deviceHDC, Int color)
void JS_GDI_SetTextBkMode(void* deviceHDC, int mode)
JS_GDI_SetTextBkMode(void* deviceHDC, int mode) (requires REAPER 6.24 or later)
extension_api("JS_GDI_SetTextBkMode", void* deviceHDC, int mode) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_SetTextBkMode(identifier deviceHDC, integer mode)
JS_GDI_SetTextBkMode(void deviceHDC, Int mode)
void JS_GDI_SetTextColor(void* deviceHDC, int color)
JS_GDI_SetTextColor(void* deviceHDC, int color) (requires REAPER 6.24 or later)
extension_api("JS_GDI_SetTextColor", void* deviceHDC, int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_SetTextColor(identifier deviceHDC, integer color)
JS_GDI_SetTextColor(void deviceHDC, Int color)
void JS_GDI_StretchBlit(void* destHDC, int dstx, int dsty, int dstw, int dsth, void* sourceHDC, int srcx, int srxy, int srcw, int srch, const char* modeOptional)
JS_GDI_StretchBlit(void* destHDC, int dstx, int dsty, int dstw, int dsth, void* sourceHDC, int srcx, int srxy, int srcw, int srch, optional "mode") (requires REAPER 6.24 or later)
extension_api("JS_GDI_StretchBlit", void* destHDC, int dstx, int dsty, int dstw, int dsth, void* sourceHDC, int srcx, int srxy, int srcw, int srch, optional "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_GDI_StretchBlit(identifier destHDC, integer dstx, integer dsty, integer dstw, integer dsth, identifier sourceHDC, integer srcx, integer srxy, integer srcw, integer srch, optional string mode)
JS_GDI_StretchBlit(void destHDC, Int dstx, Int dsty, Int dstw, Int dsth, void sourceHDC, Int srcx, Int srxy, Int srcw, Int srch, String modeOptional)

Blits between two device contexts, which may include LICE "system bitmaps".

modeOptional: "SRCCOPY" by default, or specify "ALPHA" to enable per-pixel alpha blending.

WARNING: On WindowsOS, GDI_Blit does not perform alpha multiplication of the source bitmap. For proper color rendering, a separate pre-multiplication step is therefore required, using either LICE_Blit or LICE_ProcessRect.

int JS_Header_GetItemCount(void* headerHWND)
int JS_Header_GetItemCount(void* headerHWND) (requires REAPER 6.24 or later)
int extension_api("JS_Header_GetItemCount", void* headerHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Header_GetItemCount(identifier headerHWND)
Int JS_Header_GetItemCount(void headerHWND)
void JS_Int(void* pointer, int offset, int* intOut)
JS_Int(void* pointer, int offset, int &int) (requires REAPER 6.24 or later)
extension_api("JS_Int", void* pointer, int offset, int &int) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer int = reaper.JS_Int(identifier pointer, integer offset)
(void pointer, Int offset, Int intOut) = JS_Int(pointer, offset, intOut)

Returns the 4-byte signed integer at address[offset]. Offset is added as steps of 4 bytes each.

void JS_LICE_AlterBitmapHSV(void* bitmap, double hue, double saturation, double value)
JS_LICE_AlterBitmapHSV(void* bitmap, hue, saturation, value) (requires REAPER 6.24 or later)
extension_api("JS_LICE_AlterBitmapHSV", void* bitmap, hue, saturation, value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_AlterBitmapHSV(identifier bitmap, number hue, number saturation, number value)
JS_LICE_AlterBitmapHSV(void bitmap, Float hue, Float saturation, Float value)

Hue is rolled over, saturation and value are clamped, all 0..1. (Alpha remains unchanged.)

void JS_LICE_AlterRectHSV(void* bitmap, int x, int y, int w, int h, double hue, double saturation, double value)
JS_LICE_AlterRectHSV(void* bitmap, int x, int y, int w, int h, hue, saturation, value) (requires REAPER 6.24 or later)
extension_api("JS_LICE_AlterRectHSV", void* bitmap, int x, int y, int w, int h, hue, saturation, value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_AlterRectHSV(identifier bitmap, integer x, integer y, integer w, integer h, number hue, number saturation, number value)
JS_LICE_AlterRectHSV(void bitmap, Int x, Int y, Int w, Int h, Float hue, Float saturation, Float value)

Hue is rolled over, saturation and value are clamped, all 0..1. (Alpha remains unchanged.)

void JS_LICE_Arc(void* bitmap, double cx, double cy, double r, double minAngle, double maxAngle, int color, double alpha, const char* mode, bool antialias)
JS_LICE_Arc(void* bitmap, cx, cy, r, minAngle, maxAngle, int color, alpha, "mode", bool antialias) (requires REAPER 6.24 or later)
extension_api("JS_LICE_Arc", void* bitmap, cx, cy, r, minAngle, maxAngle, int color, alpha, "mode", bool antialias) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_Arc(identifier bitmap, number cx, number cy, number r, number minAngle, number maxAngle, integer color, number alpha, string mode, boolean antialias)
JS_LICE_Arc(void bitmap, Float cx, Float cy, Float r, Float minAngle, Float maxAngle, Int color, Float alpha, String mode, Boolean antialias)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA".

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

int JS_LICE_ArrayAllBitmaps(void* reaperarray)
int JS_LICE_ArrayAllBitmaps(void* reaperarray) (requires REAPER 6.24 or later)
int extension_api("JS_LICE_ArrayAllBitmaps", void* reaperarray) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_LICE_ArrayAllBitmaps(identifier reaperarray)
Int JS_LICE_ArrayAllBitmaps(void reaperarray)
void JS_LICE_Bezier(void* bitmap, double xstart, double ystart, double xctl1, double yctl1, double xctl2, double yctl2, double xend, double yend, double tol, int color, double alpha, const char* mode, bool antialias)
JS_LICE_Bezier(void* bitmap, xstart, ystart, xctl1, yctl1, xctl2, yctl2, xend, yend, tol, int color, alpha, "mode", bool antialias) (requires REAPER 6.24 or later)
extension_api("JS_LICE_Bezier", void* bitmap, xstart, ystart, xctl1, yctl1, xctl2, yctl2, xend, yend, tol, int color, alpha, "mode", bool antialias) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_Bezier(identifier bitmap, number xstart, number ystart, number xctl1, number yctl1, number xctl2, number yctl2, number xend, number yend, number tol, integer color, number alpha, string mode, boolean antialias)
JS_LICE_Bezier(void bitmap, Float xstart, Float ystart, Float xctl1, Float yctl1, Float xctl2, Float yctl2, Float xend, Float yend, Float tol, Int color, Float alpha, String mode, Boolean antialias)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA" to enable per-pixel alpha blending.

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

void JS_LICE_Blit(void* destBitmap, int dstx, int dsty, void* sourceBitmap, int srcx, int srcy, int width, int height, double alpha, const char* mode)
JS_LICE_Blit(void* destBitmap, int dstx, int dsty, void* sourceBitmap, int srcx, int srcy, int width, int height, alpha, "mode") (requires REAPER 6.24 or later)
extension_api("JS_LICE_Blit", void* destBitmap, int dstx, int dsty, void* sourceBitmap, int srcx, int srcy, int width, int height, alpha, "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_Blit(identifier destBitmap, integer dstx, integer dsty, identifier sourceBitmap, integer srcx, integer srcy, integer width, integer height, number alpha, string mode)
JS_LICE_Blit(void destBitmap, Int dstx, Int dsty, void sourceBitmap, Int srcx, Int srcy, Int width, Int height, Float alpha, String mode)

Standard LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA" to enable per-pixel alpha blending.

In addition to the standard LICE modes, LICE_Blit also offers:
* "CHANCOPY_XTOY", with X and Y any of the four channels, A, R, G or B. (CHANCOPY_ATOA is similar to MASK mode.)
* "BLUR"
* "ALPHAMUL", which overwrites the destination with a per-pixel alpha-multiplied copy of the source. (Similar to first clearing the destination with 0x00000000 and then blitting with "COPY,ALPHA".)

void JS_LICE_Circle(void* bitmap, double cx, double cy, double r, int color, double alpha, const char* mode, bool antialias)
JS_LICE_Circle(void* bitmap, cx, cy, r, int color, alpha, "mode", bool antialias) (requires REAPER 6.24 or later)
extension_api("JS_LICE_Circle", void* bitmap, cx, cy, r, int color, alpha, "mode", bool antialias) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_Circle(identifier bitmap, number cx, number cy, number r, integer color, number alpha, string mode, boolean antialias)
JS_LICE_Circle(void bitmap, Float cx, Float cy, Float r, Int color, Float alpha, String mode, Boolean antialias)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA".

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

void JS_LICE_Clear(void* bitmap, int color)
JS_LICE_Clear(void* bitmap, int color) (requires REAPER 6.24 or later)
extension_api("JS_LICE_Clear", void* bitmap, int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_Clear(identifier bitmap, integer color)
JS_LICE_Clear(void bitmap, Int color)
void* JS_LICE_CreateBitmap(bool isSysBitmap, int width, int height)
void* JS_LICE_CreateBitmap(bool isSysBitmap, int width, int height) (requires REAPER 6.24 or later)
void* extension_api("JS_LICE_CreateBitmap", bool isSysBitmap, int width, int height) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_LICE_CreateBitmap(boolean isSysBitmap, integer width, integer height)
void JS_LICE_CreateBitmap(Boolean isSysBitmap, Int width, Int height)
void* JS_LICE_CreateFont()
void* JS_LICE_CreateFont() (requires REAPER 6.24 or later)
void* extension_api("JS_LICE_CreateFont") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_LICE_CreateFont()
void JS_LICE_CreateFont()
void JS_LICE_DestroyBitmap(void* bitmap)
JS_LICE_DestroyBitmap(void* bitmap) (requires REAPER 6.24 or later)
extension_api("JS_LICE_DestroyBitmap", void* bitmap) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_DestroyBitmap(identifier bitmap)
JS_LICE_DestroyBitmap(void bitmap)

Deletes the bitmap, and also unlinks bitmap from any composited window.

void JS_LICE_DestroyFont(void* LICEFont)
JS_LICE_DestroyFont(void* LICEFont) (requires REAPER 6.24 or later)
extension_api("JS_LICE_DestroyFont", void* LICEFont) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_DestroyFont(identifier LICEFont)
JS_LICE_DestroyFont(void LICEFont)
void JS_LICE_DrawChar(void* bitmap, int x, int y, char c, int color, double alpha, int mode))
JS_LICE_DrawChar(void* bitmap, int x, int y, char c, int color, alpha, int mode)) (requires REAPER 6.24 or later)
extension_api("JS_LICE_DrawChar", void* bitmap, int x, int y, char c, int color, alpha, int mode)) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_DrawChar(identifier bitmap, integer x, integer y, integer c, integer color, number alpha, integer mode))
JS_LICE_DrawChar(void bitmap, Int x, Int y, Int c, Int color, Float alpha, Int mode))
int JS_LICE_DrawText(void* bitmap, void* LICEFont, const char* text, int textLen, int x1, int y1, int x2, int y2)
int JS_LICE_DrawText(void* bitmap, void* LICEFont, "text", int textLen, int x1, int y1, int x2, int y2) (requires REAPER 6.24 or later)
int extension_api("JS_LICE_DrawText", void* bitmap, void* LICEFont, "text", int textLen, int x1, int y1, int x2, int y2) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_LICE_DrawText(identifier bitmap, identifier LICEFont, string text, integer textLen, integer x1, integer y1, integer x2, integer y2)
Int JS_LICE_DrawText(void bitmap, void LICEFont, String text, Int textLen, Int x1, Int y1, Int x2, Int y2)
void JS_LICE_FillCircle(void* bitmap, double cx, double cy, double r, int color, double alpha, const char* mode, bool antialias)
JS_LICE_FillCircle(void* bitmap, cx, cy, r, int color, alpha, "mode", bool antialias) (requires REAPER 6.24 or later)
extension_api("JS_LICE_FillCircle", void* bitmap, cx, cy, r, int color, alpha, "mode", bool antialias) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_FillCircle(identifier bitmap, number cx, number cy, number r, integer color, number alpha, string mode, boolean antialias)
JS_LICE_FillCircle(void bitmap, Float cx, Float cy, Float r, Int color, Float alpha, String mode, Boolean antialias)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA".

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

void JS_LICE_FillPolygon(void* bitmap, const char* packedX, const char* packedY, int numPoints, int color, double alpha, const char* mode)
JS_LICE_FillPolygon(void* bitmap, "packedX", "packedY", int numPoints, int color, alpha, "mode") (requires REAPER 6.24 or later)
extension_api("JS_LICE_FillPolygon", void* bitmap, "packedX", "packedY", int numPoints, int color, alpha, "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_FillPolygon(identifier bitmap, string packedX, string packedY, integer numPoints, integer color, number alpha, string mode)
JS_LICE_FillPolygon(void bitmap, String packedX, String packedY, Int numPoints, Int color, Float alpha, String mode)

packedX and packedY are two strings of coordinates, each packed as "<i4".

LICE modes : "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA" to enable per-pixel alpha blending.

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

void JS_LICE_FillRect(void* bitmap, int x, int y, int w, int h, int color, double alpha, const char* mode)
JS_LICE_FillRect(void* bitmap, int x, int y, int w, int h, int color, alpha, "mode") (requires REAPER 6.24 or later)
extension_api("JS_LICE_FillRect", void* bitmap, int x, int y, int w, int h, int color, alpha, "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_FillRect(identifier bitmap, integer x, integer y, integer w, integer h, integer color, number alpha, string mode)
JS_LICE_FillRect(void bitmap, Int x, Int y, Int w, Int h, Int color, Float alpha, String mode)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA".

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

void JS_LICE_FillTriangle(void* bitmap, int x1, int y1, int x2, int y2, int x3, int y3, int color, double alpha, const char* mode)
JS_LICE_FillTriangle(void* bitmap, int x1, int y1, int x2, int y2, int x3, int y3, int color, alpha, "mode") (requires REAPER 6.24 or later)
extension_api("JS_LICE_FillTriangle", void* bitmap, int x1, int y1, int x2, int y2, int x3, int y3, int color, alpha, "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_FillTriangle(identifier bitmap, integer x1, integer y1, integer x2, integer y2, integer x3, integer y3, integer color, number alpha, string mode)
JS_LICE_FillTriangle(void bitmap, Int x1, Int y1, Int x2, Int y2, Int x3, Int y3, Int color, Float alpha, String mode)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA".

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

void* JS_LICE_GetDC(void* bitmap)
void* JS_LICE_GetDC(void* bitmap) (requires REAPER 6.24 or later)
void* extension_api("JS_LICE_GetDC", void* bitmap) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_LICE_GetDC(identifier bitmap)
void JS_LICE_GetDC(void bitmap)
int JS_LICE_GetHeight(void* bitmap)
int JS_LICE_GetHeight(void* bitmap) (requires REAPER 6.24 or later)
int extension_api("JS_LICE_GetHeight", void* bitmap) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_LICE_GetHeight(identifier bitmap)
Int JS_LICE_GetHeight(void bitmap)
void JS_LICE_GetPixel(void* bitmap, int x, int y, double* colorOut)
JS_LICE_GetPixel(void* bitmap, int x, int y, &color) (requires REAPER 6.24 or later)
extension_api("JS_LICE_GetPixel", void* bitmap, int x, int y, &color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number color = reaper.JS_LICE_GetPixel(identifier bitmap, integer x, integer y)
(void bitmap, Int x, Int y, Float colorOut) = JS_LICE_GetPixel(bitmap, x, y, colorOut)

Returns the color of the specified pixel.

int JS_LICE_GetWidth(void* bitmap)
int JS_LICE_GetWidth(void* bitmap) (requires REAPER 6.24 or later)
int extension_api("JS_LICE_GetWidth", void* bitmap) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_LICE_GetWidth(identifier bitmap)
Int JS_LICE_GetWidth(void bitmap)
void JS_LICE_GradRect(void* bitmap, int dstx, int dsty, int dstw, int dsth, double ir, double ig, double ib, double ia, double drdx, double dgdx, double dbdx, double dadx, double drdy, double dgdy, double dbdy, double dady, const char* mode)
JS_LICE_GradRect(void* bitmap, int dstx, int dsty, int dstw, int dsth, ir, ig, ib, ia, drdx, dgdx, dbdx, dadx, drdy, dgdy, dbdy, dady, "mode") (requires REAPER 6.24 or later)
extension_api("JS_LICE_GradRect", void* bitmap, int dstx, int dsty, int dstw, int dsth, ir, ig, ib, ia, drdx, dgdx, dbdx, dadx, drdy, dgdy, dbdy, dady, "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_GradRect(identifier bitmap, integer dstx, integer dsty, integer dstw, integer dsth, number ir, number ig, number ib, number ia, number drdx, number dgdx, number dbdx, number dadx, number drdy, number dgdy, number dbdy, number dady, string mode)
JS_LICE_GradRect(void bitmap, Int dstx, Int dsty, Int dstw, Int dsth, Float ir, Float ig, Float ib, Float ia, Float drdx, Float dgdx, Float dbdx, Float dadx, Float drdy, Float dgdy, Float dbdy, Float dady, String mode)
bool JS_LICE_IsFlipped(void* bitmap)
bool JS_LICE_IsFlipped(void* bitmap) (requires REAPER 6.24 or later)
bool extension_api("JS_LICE_IsFlipped", void* bitmap) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_LICE_IsFlipped(identifier bitmap)
Boolean JS_LICE_IsFlipped(void bitmap)
void JS_LICE_Line(void* bitmap, double x1, double y1, double x2, double y2, int color, double alpha, const char* mode, bool antialias)
JS_LICE_Line(void* bitmap, x1, y1, x2, y2, int color, alpha, "mode", bool antialias) (requires REAPER 6.24 or later)
extension_api("JS_LICE_Line", void* bitmap, x1, y1, x2, y2, int color, alpha, "mode", bool antialias) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_Line(identifier bitmap, number x1, number y1, number x2, number y2, integer color, number alpha, string mode, boolean antialias)
JS_LICE_Line(void bitmap, Float x1, Float y1, Float x2, Float y2, Int color, Float alpha, String mode, Boolean antialias)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA".

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

int JS_LICE_ListAllBitmaps(char* listOutNeedBig, int listOutNeedBig_sz)
int JS_LICE_ListAllBitmaps(#list) (requires REAPER 6.24 or later)
int extension_api("JS_LICE_ListAllBitmaps", #list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string list = reaper.JS_LICE_ListAllBitmaps()
(Int retval, String listOutNeedBig, Int listOutNeedBig_sz) = JS_LICE_ListAllBitmaps(listOutNeedBig, listOutNeedBig_sz)
void* JS_LICE_LoadJPG(const char* filename)
void* JS_LICE_LoadJPG("filename") (requires REAPER 6.24 or later)
void* extension_api("JS_LICE_LoadJPG", "filename") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_LICE_LoadJPG(string filename)
void JS_LICE_LoadJPG(String filename)

Returns a system LICE bitmap containing the JPEG.

void* JS_LICE_LoadJPGFromMemory(const char* buffer, int bufsize)
void* JS_LICE_LoadJPGFromMemory("buffer", int bufsize) (requires REAPER 6.24 or later)
void* extension_api("JS_LICE_LoadJPGFromMemory", "buffer", int bufsize) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_LICE_LoadJPGFromMemory(string buffer, integer bufsize)
void JS_LICE_LoadJPGFromMemory(String buffer, Int bufsize)

Returns a system LICE bitmap containing the JPEG.

void* JS_LICE_LoadPNG(const char* filename)
void* JS_LICE_LoadPNG("filename") (requires REAPER 6.24 or later)
void* extension_api("JS_LICE_LoadPNG", "filename") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_LICE_LoadPNG(string filename)
void JS_LICE_LoadPNG(String filename)

Returns a system LICE bitmap containing the PNG.

void* JS_LICE_LoadPNGFromMemory(const char* buffer, int bufsize)
void* JS_LICE_LoadPNGFromMemory("buffer", int bufsize) (requires REAPER 6.24 or later)
void* extension_api("JS_LICE_LoadPNGFromMemory", "buffer", int bufsize) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_LICE_LoadPNGFromMemory(string buffer, integer bufsize)
void JS_LICE_LoadPNGFromMemory(String buffer, Int bufsize)

Returns a system LICE bitmap containing the PNG.

void JS_LICE_MeasureText(const char* text, int* widthOut, int* HeightOut)
JS_LICE_MeasureText("text", int &width, int &Height) (requires REAPER 6.24 or later)
extension_api("JS_LICE_MeasureText", "text", int &width, int &Height) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer width, integer Height = reaper.JS_LICE_MeasureText(string text)
(String text, Int widthOut, Int HeightOut) = JS_LICE_MeasureText(text, widthOut, HeightOut)
bool JS_LICE_ProcessRect(void* bitmap, int x, int y, int w, int h, const char* mode, double operand)
bool JS_LICE_ProcessRect(void* bitmap, int x, int y, int w, int h, "mode", operand) (requires REAPER 6.24 or later)
bool extension_api("JS_LICE_ProcessRect", void* bitmap, int x, int y, int w, int h, "mode", operand) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_LICE_ProcessRect(identifier bitmap, integer x, integer y, integer w, integer h, string mode, number operand)
Boolean JS_LICE_ProcessRect(void bitmap, Int x, Int y, Int w, Int h, String mode, Float operand)

Applies bitwise operations to each pixel in the target rectangle.

operand: a color in 0xAARRGGBB format.

modes:
* "XOR", "OR" or "AND".
* "SET_XYZ", with XYZ any combination of A, R, G, and B: copies the specified channels from operand to the bitmap. (Useful for setting the alpha values of a bitmap.)
* "ALPHAMUL": Performs alpha pre-multiplication on each pixel in the rect. operand is ignored in this mode. (On WindowsOS, GDI_Blit does not perform alpha multiplication on the fly, and a separate alpha pre-multiplication step is therefore required.)

NOTE:
LICE_Blit and LICE_ScaledBlit are also useful for processing bitmap colors. For example, to multiply all channel values by 1.5:
reaper.JS_LICE_Blit(bitmap, x, y, bitmap, x, y, w, h, 0.5, "ADD").

void JS_LICE_PutPixel(void* bitmap, int x, int y, double color, double alpha, const char* mode)
JS_LICE_PutPixel(void* bitmap, int x, int y, color, alpha, "mode") (requires REAPER 6.24 or later)
extension_api("JS_LICE_PutPixel", void* bitmap, int x, int y, color, alpha, "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_PutPixel(identifier bitmap, integer x, integer y, number color, number alpha, string mode)
JS_LICE_PutPixel(void bitmap, Int x, Int y, Float color, Float alpha, String mode)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA".

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

void JS_LICE_Resize(void* bitmap, int width, int height)
JS_LICE_Resize(void* bitmap, int width, int height) (requires REAPER 6.24 or later)
extension_api("JS_LICE_Resize", void* bitmap, int width, int height) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_Resize(identifier bitmap, integer width, integer height)
JS_LICE_Resize(void bitmap, Int width, Int height)
void JS_LICE_RotatedBlit(void* destBitmap, int dstx, int dsty, int dstw, int dsth, void* sourceBitmap, double srcx, double srcy, double srcw, double srch, double angle, double rotxcent, double rotycent, bool cliptosourcerect, double alpha, const char* mode)
JS_LICE_RotatedBlit(void* destBitmap, int dstx, int dsty, int dstw, int dsth, void* sourceBitmap, srcx, srcy, srcw, srch, angle, rotxcent, rotycent, bool cliptosourcerect, alpha, "mode") (requires REAPER 6.24 or later)
extension_api("JS_LICE_RotatedBlit", void* destBitmap, int dstx, int dsty, int dstw, int dsth, void* sourceBitmap, srcx, srcy, srcw, srch, angle, rotxcent, rotycent, bool cliptosourcerect, alpha, "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_RotatedBlit(identifier destBitmap, integer dstx, integer dsty, integer dstw, integer dsth, identifier sourceBitmap, number srcx, number srcy, number srcw, number srch, number angle, number rotxcent, number rotycent, boolean cliptosourcerect, number alpha, string mode)
JS_LICE_RotatedBlit(void destBitmap, Int dstx, Int dsty, Int dstw, Int dsth, void sourceBitmap, Float srcx, Float srcy, Float srcw, Float srch, Float angle, Float rotxcent, Float rotycent, Boolean cliptosourcerect, Float alpha, String mode)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA" to enable per-pixel alpha blending.

void JS_LICE_RoundRect(void* bitmap, double x, double y, double w, double h, int cornerradius, int color, double alpha, const char* mode, bool antialias)
JS_LICE_RoundRect(void* bitmap, x, y, w, h, int cornerradius, int color, alpha, "mode", bool antialias) (requires REAPER 6.24 or later)
extension_api("JS_LICE_RoundRect", void* bitmap, x, y, w, h, int cornerradius, int color, alpha, "mode", bool antialias) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_RoundRect(identifier bitmap, number x, number y, number w, number h, integer cornerradius, integer color, number alpha, string mode, boolean antialias)
JS_LICE_RoundRect(void bitmap, Float x, Float y, Float w, Float h, Int cornerradius, Int color, Float alpha, String mode, Boolean antialias)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA".

LICE color format: 0xAARRGGBB (AA is only used in ALPHA mode).

void JS_LICE_ScaledBlit(void* destBitmap, int dstx, int dsty, int dstw, int dsth, void* srcBitmap, double srcx, double srcy, double srcw, double srch, double alpha, const char* mode)
JS_LICE_ScaledBlit(void* destBitmap, int dstx, int dsty, int dstw, int dsth, void* srcBitmap, srcx, srcy, srcw, srch, alpha, "mode") (requires REAPER 6.24 or later)
extension_api("JS_LICE_ScaledBlit", void* destBitmap, int dstx, int dsty, int dstw, int dsth, void* srcBitmap, srcx, srcy, srcw, srch, alpha, "mode") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_ScaledBlit(identifier destBitmap, integer dstx, integer dsty, integer dstw, integer dsth, identifier srcBitmap, number srcx, number srcy, number srcw, number srch, number alpha, string mode)
JS_LICE_ScaledBlit(void destBitmap, Int dstx, Int dsty, Int dstw, Int dsth, void srcBitmap, Float srcx, Float srcy, Float srcw, Float srch, Float alpha, String mode)

LICE modes: "COPY" (default if empty string), "MASK", "ADD", "DODGE", "MUL", "OVERLAY" or "HSVADJ", any of which may be combined with "ALPHA" to enable per-pixel alpha blending.

void JS_LICE_SetAlphaFromColorMask(void* bitmap, int colorRGB)
JS_LICE_SetAlphaFromColorMask(void* bitmap, int colorRGB) (requires REAPER 6.24 or later)
extension_api("JS_LICE_SetAlphaFromColorMask", void* bitmap, int colorRGB) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_SetAlphaFromColorMask(identifier bitmap, integer colorRGB)
JS_LICE_SetAlphaFromColorMask(void bitmap, Int colorRGB)

Sets all pixels that match the given color's RGB values to fully transparent, and all other pixels to fully opaque. (All pixels' RGB values remain unchanged.)

void JS_LICE_SetFontBkColor(void* LICEFont, int color)
JS_LICE_SetFontBkColor(void* LICEFont, int color) (requires REAPER 6.24 or later)
extension_api("JS_LICE_SetFontBkColor", void* LICEFont, int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_SetFontBkColor(identifier LICEFont, integer color)
JS_LICE_SetFontBkColor(void LICEFont, Int color)

Sets the color of the font background.

void JS_LICE_SetFontColor(void* LICEFont, int color)
JS_LICE_SetFontColor(void* LICEFont, int color) (requires REAPER 6.24 or later)
extension_api("JS_LICE_SetFontColor", void* LICEFont, int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_SetFontColor(identifier LICEFont, integer color)
JS_LICE_SetFontColor(void LICEFont, Int color)
void JS_LICE_SetFontFXColor(void* LICEFont, int color)
JS_LICE_SetFontFXColor(void* LICEFont, int color) (requires REAPER 6.24 or later)
extension_api("JS_LICE_SetFontFXColor", void* LICEFont, int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_SetFontFXColor(identifier LICEFont, integer color)
JS_LICE_SetFontFXColor(void LICEFont, Int color)

Sets the color of font FX such as shadow.

void JS_LICE_SetFontFromGDI(void* LICEFont, void* GDIFont, const char* moreFormats)
JS_LICE_SetFontFromGDI(void* LICEFont, void* GDIFont, "moreFormats") (requires REAPER 6.24 or later)
extension_api("JS_LICE_SetFontFromGDI", void* LICEFont, void* GDIFont, "moreFormats") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_LICE_SetFontFromGDI(identifier LICEFont, identifier GDIFont, string moreFormats)
JS_LICE_SetFontFromGDI(void LICEFont, void GDIFont, String moreFormats)

Converts a GDI font into a LICE font.

The font can be modified by the following flags, in a comma-separated list:
"VERTICAL", "BOTTOMUP", "NATIVE", "BLUR", "INVERT", "MONO", "SHADOW" or "OUTLINE".

bool JS_LICE_WriteJPG(const char* filename, void* bitmap, int quality, bool* forceBaselineOptional)
bool JS_LICE_WriteJPG("filename", void* bitmap, int quality, unsupported forceBaselineOptional) (requires REAPER 6.24 or later)
bool extension_api("JS_LICE_WriteJPG", "filename", void* bitmap, int quality, unsupported forceBaselineOptional) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_LICE_WriteJPG(string filename, identifier bitmap, integer quality, unsupported forceBaseline)
(Boolean retval, String filename, void bitmap, Int quality, Boolean forceBaselineOptional) = JS_LICE_WriteJPG(filename, bitmap, quality, forceBaselineOptional)

Parameters:

* quality is an integer in the range 1..100.
* forceBaseline is an optional boolean parameter that ensures compatibility with all JPEG viewers by preventing too low quality, "cubist" settings.

bool JS_LICE_WritePNG(const char* filename, void* bitmap, bool wantAlpha)
bool JS_LICE_WritePNG("filename", void* bitmap, bool wantAlpha) (requires REAPER 6.24 or later)
bool extension_api("JS_LICE_WritePNG", "filename", void* bitmap, bool wantAlpha) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_LICE_WritePNG(string filename, identifier bitmap, boolean wantAlpha)
Boolean JS_LICE_WritePNG(String filename, void bitmap, Boolean wantAlpha)
void JS_ListView_EnsureVisible(void* listviewHWND, int index, bool partialOK)
JS_ListView_EnsureVisible(void* listviewHWND, int index, bool partialOK) (requires REAPER 6.24 or later)
extension_api("JS_ListView_EnsureVisible", void* listviewHWND, int index, bool partialOK) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_ListView_EnsureVisible(identifier listviewHWND, integer index, boolean partialOK)
JS_ListView_EnsureVisible(void listviewHWND, Int index, Boolean partialOK)
int JS_ListView_EnumSelItems(void* listviewHWND, int index)
int JS_ListView_EnumSelItems(void* listviewHWND, int index) (requires REAPER 6.24 or later)
int extension_api("JS_ListView_EnumSelItems", void* listviewHWND, int index) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_ListView_EnumSelItems(identifier listviewHWND, integer index)
Int JS_ListView_EnumSelItems(void listviewHWND, Int index)

Returns the index of the next selected list item with index greater that the specified number. Returns -1 if no selected items left.

int JS_ListView_GetFocusedItem(void* listviewHWND, char* textOut, int textOut_sz)
int JS_ListView_GetFocusedItem(void* listviewHWND, #text) (requires REAPER 6.24 or later)
int extension_api("JS_ListView_GetFocusedItem", void* listviewHWND, #text) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string text = reaper.JS_ListView_GetFocusedItem(identifier listviewHWND)
(Int retval, void listviewHWND, String textOut, Int textOut_sz) = JS_ListView_GetFocusedItem(listviewHWND, textOut, textOut_sz)

Returns the index and text of the focused item, if any.

void* JS_ListView_GetHeader(void* listviewHWND)
void* JS_ListView_GetHeader(void* listviewHWND) (requires REAPER 6.24 or later)
void* extension_api("JS_ListView_GetHeader", void* listviewHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_ListView_GetHeader(identifier listviewHWND)
void JS_ListView_GetHeader(void listviewHWND)
void JS_ListView_GetItem(void* listviewHWND, int index, int subItem, char* textOut, int textOut_sz, int* stateOut)
JS_ListView_GetItem(void* listviewHWND, int index, int subItem, #text, int &state) (requires REAPER 6.24 or later)
extension_api("JS_ListView_GetItem", void* listviewHWND, int index, int subItem, #text, int &state) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string text, integer state = reaper.JS_ListView_GetItem(identifier listviewHWND, integer index, integer subItem)
(void listviewHWND, Int index, Int subItem, String textOut, Int textOut_sz, Int stateOut) = JS_ListView_GetItem(listviewHWND, index, subItem, textOut, textOut_sz, stateOut)

Returns the text and state of specified item.

int JS_ListView_GetItemCount(void* listviewHWND)
int JS_ListView_GetItemCount(void* listviewHWND) (requires REAPER 6.24 or later)
int extension_api("JS_ListView_GetItemCount", void* listviewHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_ListView_GetItemCount(identifier listviewHWND)
Int JS_ListView_GetItemCount(void listviewHWND)
bool JS_ListView_GetItemRect(void* listviewHWND, int index, int* leftOut, int* topOut, int* rightOut, int* bottomOut)
bool JS_ListView_GetItemRect(void* listviewHWND, int index, int &left, int &top, int &right, int &bottom) (requires REAPER 6.24 or later)
bool extension_api("JS_ListView_GetItemRect", void* listviewHWND, int index, int &left, int &top, int &right, int &bottom) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer left, integer top, integer right, integer bottom = reaper.JS_ListView_GetItemRect(identifier listviewHWND, integer index)
(Boolean retval, void listviewHWND, Int index, Int leftOut, Int topOut, Int rightOut, Int bottomOut) = JS_ListView_GetItemRect(listviewHWND, index, leftOut, topOut, rightOut, bottomOut)

Returns client coordinates of the item.

int JS_ListView_GetItemState(void* listviewHWND, int index)
int JS_ListView_GetItemState(void* listviewHWND, int index) (requires REAPER 6.24 or later)
int extension_api("JS_ListView_GetItemState", void* listviewHWND, int index) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_ListView_GetItemState(identifier listviewHWND, integer index)
Int JS_ListView_GetItemState(void listviewHWND, Int index)

State is a bitmask:
1 = focused, 2 = selected. On Windows only, cut-and-paste marked = 4, drag-and-drop highlighted = 8.

Warning: this function uses the Win32 bitmask values, which differ from the values used by WDL/swell.

void JS_ListView_GetItemText(void* listviewHWND, int index, int subItem, char* textOut, int textOut_sz)
JS_ListView_GetItemText(void* listviewHWND, int index, int subItem, #text) (requires REAPER 6.24 or later)
extension_api("JS_ListView_GetItemText", void* listviewHWND, int index, int subItem, #text) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string text = reaper.JS_ListView_GetItemText(identifier listviewHWND, integer index, integer subItem)
(void listviewHWND, Int index, Int subItem, String textOut, Int textOut_sz) = JS_ListView_GetItemText(listviewHWND, index, subItem, textOut, textOut_sz)
int JS_ListView_GetSelectedCount(void* listviewHWND)
int JS_ListView_GetSelectedCount(void* listviewHWND) (requires REAPER 6.24 or later)
int extension_api("JS_ListView_GetSelectedCount", void* listviewHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_ListView_GetSelectedCount(identifier listviewHWND)
Int JS_ListView_GetSelectedCount(void listviewHWND)
int JS_ListView_GetTopIndex(void* listviewHWND)
int JS_ListView_GetTopIndex(void* listviewHWND) (requires REAPER 6.24 or later)
int extension_api("JS_ListView_GetTopIndex", void* listviewHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_ListView_GetTopIndex(identifier listviewHWND)
Int JS_ListView_GetTopIndex(void listviewHWND)
void JS_ListView_HitTest(void* listviewHWND, int clientX, int clientY, int* indexOut, int* subItemOut, int* flagsOut)
JS_ListView_HitTest(void* listviewHWND, int clientX, int clientY, int &index, int &subItem, int &flags) (requires REAPER 6.24 or later)
extension_api("JS_ListView_HitTest", void* listviewHWND, int clientX, int clientY, int &index, int &subItem, int &flags) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer index, integer subItem, integer flags = reaper.JS_ListView_HitTest(identifier listviewHWND, integer clientX, integer clientY)
(void listviewHWND, Int clientX, Int clientY, Int indexOut, Int subItemOut, Int flagsOut) = JS_ListView_HitTest(listviewHWND, clientX, clientY, indexOut, subItemOut, flagsOut)
int JS_ListView_ListAllSelItems(void* listviewHWND, char* itemsOutNeedBig, int itemsOutNeedBig_sz)
int JS_ListView_ListAllSelItems(void* listviewHWND, #items) (requires REAPER 6.24 or later)
int extension_api("JS_ListView_ListAllSelItems", void* listviewHWND, #items) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string items = reaper.JS_ListView_ListAllSelItems(identifier listviewHWND)
(Int retval, void listviewHWND, String itemsOutNeedBig, Int itemsOutNeedBig_sz) = JS_ListView_ListAllSelItems(listviewHWND, itemsOutNeedBig, itemsOutNeedBig_sz)

Returns the indices of all selected items as a comma-separated list.

* retval: Number of selected items found; negative or zero if an error occured.

void JS_ListView_SetItemState(void* listviewHWND, int index, int state, int mask)
JS_ListView_SetItemState(void* listviewHWND, int index, int state, int mask) (requires REAPER 6.24 or later)
extension_api("JS_ListView_SetItemState", void* listviewHWND, int index, int state, int mask) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_ListView_SetItemState(identifier listviewHWND, integer index, integer state, integer mask)
JS_ListView_SetItemState(void listviewHWND, Int index, Int state, Int mask)

The mask parameter specifies the state bits that must be set, and the state parameter specifies the new values for those bits.

1 = focused, 2 = selected. On Windows only, cut-and-paste marked = 4, drag-and-drop highlighted = 8.

Warning: this function uses the Win32 bitmask values, which differ from the values used by WDL/swell.

void JS_ListView_SetItemText(void* listviewHWND, int index, int subItem, const char* text)
JS_ListView_SetItemText(void* listviewHWND, int index, int subItem, "text") (requires REAPER 6.24 or later)
extension_api("JS_ListView_SetItemText", void* listviewHWND, int index, int subItem, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_ListView_SetItemText(identifier listviewHWND, integer index, integer subItem, string text)
JS_ListView_SetItemText(void listviewHWND, Int index, Int subItem, String text)

Currently, this fuction only accepts ASCII text.

void JS_Localize(const char* USEnglish, const char* LangPackSection, char* translationOut, int translationOut_sz)
JS_Localize("USEnglish", "LangPackSection", #translation) (requires REAPER 6.24 or later)
extension_api("JS_Localize", "USEnglish", "LangPackSection", #translation) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string translation = reaper.JS_Localize(string USEnglish, string LangPackSection)
(String USEnglish, String LangPackSection, String translationOut, Int translationOut_sz) = JS_Localize(USEnglish, LangPackSection, translationOut, translationOut_sz)

Returns the translation of the given US English text, according to the currently loaded Language Pack.

Parameters:
* LangPackSection: Language Packs are divided into sections such as "common" or "DLG_102".
* In Lua, by default, text of up to 1024 chars can be returned. To increase (or reduce) the default buffer size, a string and size can be included as optional 3rd and 4th arguments.

Example: reaper.JS_Localize("Actions", "common", "", 20)

int JS_MIDIEditor_ArrayAll(void* reaperarray)
int JS_MIDIEditor_ArrayAll(void* reaperarray) (requires REAPER 6.24 or later)
int extension_api("JS_MIDIEditor_ArrayAll", void* reaperarray) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_MIDIEditor_ArrayAll(identifier reaperarray)
Int JS_MIDIEditor_ArrayAll(void reaperarray)

Finds all open MIDI windows (whether docked or not).

* retval: The number of MIDI editor windows found; negative if an error occurred.

* The address of each MIDI editor window is stored in the provided reaper.array. Each address can be converted to a REAPER object (HWND) by the function JS_Window_HandleFromAddress.

int JS_MIDIEditor_ListAll(char* listOutNeedBig, int listOutNeedBig_sz)
int JS_MIDIEditor_ListAll(#list) (requires REAPER 6.24 or later)
int extension_api("JS_MIDIEditor_ListAll", #list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string list = reaper.JS_MIDIEditor_ListAll()
(Int retval, String listOutNeedBig, Int listOutNeedBig_sz) = JS_MIDIEditor_ListAll(listOutNeedBig, listOutNeedBig_sz)

Finds all open MIDI windows (whether docked or not).

* retval: The number of MIDI editor windows found; negative if an error occurred.

* list: Comma-separated string of hexadecimal values. Each value is an address that can be converted to a HWND by the function Window_HandleFromAddress.

void* JS_Mem_Alloc(int sizeBytes)
void* JS_Mem_Alloc(int sizeBytes) (requires REAPER 6.24 or later)
void* extension_api("JS_Mem_Alloc", int sizeBytes) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Mem_Alloc(integer sizeBytes)
void JS_Mem_Alloc(Int sizeBytes)

Allocates memory for general use by functions that require memory buffers.

bool JS_Mem_Free(void* mallocPointer)
bool JS_Mem_Free(void* mallocPointer) (requires REAPER 6.24 or later)
bool extension_api("JS_Mem_Free", void* mallocPointer) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Mem_Free(identifier mallocPointer)
Boolean JS_Mem_Free(void mallocPointer)

Frees memory that was previously allocated by JS_Mem_Alloc.

bool JS_Mem_FromString(void* mallocPointer, int offset, const char* packedString, int stringLength)
bool JS_Mem_FromString(void* mallocPointer, int offset, "packedString", int stringLength) (requires REAPER 6.24 or later)
bool extension_api("JS_Mem_FromString", void* mallocPointer, int offset, "packedString", int stringLength) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Mem_FromString(identifier mallocPointer, integer offset, string packedString, integer stringLength)
Boolean JS_Mem_FromString(void mallocPointer, Int offset, String packedString, Int stringLength)

Copies a packed string into a memory buffer.

void* JS_Mouse_GetCursor()
void* JS_Mouse_GetCursor() (requires REAPER 6.24 or later)
void* extension_api("JS_Mouse_GetCursor") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Mouse_GetCursor()
void JS_Mouse_GetCursor()

On Windows, retrieves a handle to the current mouse cursor.
On Linux and macOS, retrieves a handle to the last cursor set by REAPER or its extensions via SWELL.

int JS_Mouse_GetState(int flags)
int JS_Mouse_GetState(int flags) (requires REAPER 6.24 or later)
int extension_api("JS_Mouse_GetState", int flags) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Mouse_GetState(integer flags)
Int JS_Mouse_GetState(Int flags)

Retrieves the states of mouse buttons and modifiers keys.

Parameters:
* flags, state: The parameter and the return value both use the same format as gfx.mouse_cap. For example, to get the states of the left mouse button and the ctrl key, use flags = 0b00000101.

void* JS_Mouse_LoadCursor(int cursorNumber)
void* JS_Mouse_LoadCursor(int cursorNumber) (requires REAPER 6.24 or later)
void* extension_api("JS_Mouse_LoadCursor", int cursorNumber) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Mouse_LoadCursor(integer cursorNumber)
void JS_Mouse_LoadCursor(Int cursorNumber)

Loads a cursor by number.

cursorNumber: Same as used for gfx.setcursor, and includes some of Windows' predefined cursors (with numbers > 32000; refer to documentation for the Win32 C++ function LoadCursor), and REAPER's own cursors (with numbers < 2000).

If successful, returns a handle to the cursor, which can be used in JS_Mouse_SetCursor.

void* JS_Mouse_LoadCursorFromFile(const char* pathAndFileName, bool* forceNewLoadOptional)
void* JS_Mouse_LoadCursorFromFile("pathAndFileName", unsupported forceNewLoadOptional) (requires REAPER 6.24 or later)
void* extension_api("JS_Mouse_LoadCursorFromFile", "pathAndFileName", unsupported forceNewLoadOptional) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Mouse_LoadCursorFromFile(string pathAndFileName, unsupported forceNewLoad)
(void retval, String pathAndFileName, Boolean forceNewLoadOptional) = JS_Mouse_LoadCursorFromFile(pathAndFileName, forceNewLoadOptional)

Loads a cursor from a .cur file.

forceNewLoad is an optional boolean parameter:
* If omitted or false, and if the cursor file has already been loaded previously during the REAPER session by any script, the file will not be re-loaded, and the existing handle will be returned.
* If true, the file will be re-loaded and a new handle will be returned.
* WARNING: Each time that a cursor file is re-loaded, the number of GDI objects increases for the entire duration of the REAPER session.

If successful, returns a handle to the cursor, which can be used in JS_Mouse_SetCursor.

void JS_Mouse_SetCursor(void* cursorHandle)
JS_Mouse_SetCursor(void* cursorHandle) (requires REAPER 6.24 or later)
extension_api("JS_Mouse_SetCursor", void* cursorHandle) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Mouse_SetCursor(identifier cursorHandle)
JS_Mouse_SetCursor(void cursorHandle)

Sets the mouse cursor. (Only lasts while script is running, and for a single "defer" cycle.)

bool JS_Mouse_SetPosition(int x, int y)
bool JS_Mouse_SetPosition(int x, int y) (requires REAPER 6.24 or later)
bool extension_api("JS_Mouse_SetPosition", int x, int y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Mouse_SetPosition(integer x, integer y)
Boolean JS_Mouse_SetPosition(Int x, Int y)

Moves the mouse cursor to the specified screen coordinates.

NOTES:
* On Windows and Linux, screen coordinates are relative to *upper* left corner of the primary display, and the positive Y-axis points downward.
* On macOS, screen coordinates are relative to the *bottom* left corner of the primary display, and the positive Y-axis points upward.

void JS_ReaScriptAPI_Version(double* versionOut)
JS_ReaScriptAPI_Version(&version) (requires REAPER 6.24 or later)
extension_api("JS_ReaScriptAPI_Version", &version) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number version = reaper.JS_ReaScriptAPI_Version()
(Float versionOut) JS_ReaScriptAPI_Version(versionOut)

Returns the version of the js_ReaScriptAPI extension.

bool JS_String(void* pointer, int offset, int lengthChars, char* bufOutNeedBig, int bufOutNeedBig_sz)
bool JS_String(void* pointer, int offset, int lengthChars, #buf) (requires REAPER 6.24 or later)
bool extension_api("JS_String", void* pointer, int offset, int lengthChars, #buf) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string buf = reaper.JS_String(identifier pointer, integer offset, integer lengthChars)
(Boolean retval, void pointer, Int offset, Int lengthChars, String bufOutNeedBig, Int bufOutNeedBig_sz) = JS_String(pointer, offset, lengthChars, bufOutNeedBig, bufOutNeedBig_sz)

Returns the memory contents starting at address[offset] as a packed string. Offset is added as steps of 1 byte (char) each.

void JS_VKeys_GetDown(double cutoffTime, char* stateOutNeedBig, int* stateOutNeedBig_sz)
JS_VKeys_GetDown(cutoffTime, #state) (requires REAPER 6.24 or later)
extension_api("JS_VKeys_GetDown", cutoffTime, #state) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string state = reaper.JS_VKeys_GetDown(number cutoffTime)
(Float cutoffTime, String stateOutNeedBig, Int stateOutNeedBig_sz) = JS_VKeys_GetDown(cutoffTime, stateOutNeedBig, stateOutNeedBig_sz)

Returns a 255-byte array that specifies which virtual keys, from 0x01 to 0xFF, have sent KEYDOWN messages since cutoffTime.

Notes:
* Mouse buttons and modifier keys are not (currently) reliably detected, and JS_Mouse_GetState can be used instead.
* Auto-repeated KEYDOWN messages are ignored.

void JS_VKeys_GetState(double cutoffTime, char* stateOutNeedBig, int* stateOutNeedBig_sz)
JS_VKeys_GetState(cutoffTime, #state) (requires REAPER 6.24 or later)
extension_api("JS_VKeys_GetState", cutoffTime, #state) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string state = reaper.JS_VKeys_GetState(number cutoffTime)
(Float cutoffTime, String stateOutNeedBig, Int stateOutNeedBig_sz) = JS_VKeys_GetState(cutoffTime, stateOutNeedBig, stateOutNeedBig_sz)

Retrieves the current states (0 or 1) of all virtual keys, from 0x01 to 0xFF, in a 255-byte array.

cutoffTime: A key is only regarded as down if it sent a KEYDOWN message after the cut-off time, not followed by KEYUP. (This is useful for excluding old KEYDOWN messages that weren't properly followed by KEYUP.)
If cutoffTime is positive, is it interpreted as absolute time in similar format as time_precise().
If cutoffTime is negative, it is relative to the current time.

Notes:
* Mouse buttons and modifier keys are not (currently) reliably detected, and JS_Mouse_GetState can be used instead.
* Auto-repeated KEYDOWN messages are ignored.

void JS_VKeys_GetUp(double cutoffTime, char* stateOutNeedBig, int* stateOutNeedBig_sz)
JS_VKeys_GetUp(cutoffTime, #state) (requires REAPER 6.24 or later)
extension_api("JS_VKeys_GetUp", cutoffTime, #state) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string state = reaper.JS_VKeys_GetUp(number cutoffTime)
(Float cutoffTime, String stateOutNeedBig, Int stateOutNeedBig_sz) = JS_VKeys_GetUp(cutoffTime, stateOutNeedBig, stateOutNeedBig_sz)

Return a 255-byte array that specifies which virtual keys, from 0x01 to 0xFF, have sent KEYUP messages since cutoffTime.

Note: Mouse buttons and modifier keys are not (currently) reliably detected, and JS_Mouse_GetState can be used instead.

int JS_VKeys_Intercept(int keyCode, int intercept)
int JS_VKeys_Intercept(int keyCode, int intercept) (requires REAPER 6.24 or later)
int extension_api("JS_VKeys_Intercept", int keyCode, int intercept) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_VKeys_Intercept(integer keyCode, integer intercept)
Int JS_VKeys_Intercept(Int keyCode, Int intercept)

Intercepting (blocking) virtual keys work similar to the native function PreventUIRefresh: Each key has a (non-negative) intercept state, and the key is passed through as usual if the state equals 0, or blocked if the state is greater than 0.

keyCode: The virtual key code of the key, or -1 to change the state of all keys.

intercept: A script can increase the intercept state by passing +1, or lower the state by passing -1. Multiple scripts can block the same key, and the intercept state may reach up to 255. If zero is passed, the intercept state is not changed, but the current state is returned.

Returns: If keyCode refers to a single key, the intercept state of that key is returned. If keyCode = -1, the state of the key that is most strongly blocked (highest intercept state) is returned.

int JS_WindowMessage_Intercept(void* windowHWND, const char* message, bool passThrough)
int JS_WindowMessage_Intercept(void* windowHWND, "message", bool passThrough) (requires REAPER 6.24 or later)
int extension_api("JS_WindowMessage_Intercept", void* windowHWND, "message", bool passThrough) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_WindowMessage_Intercept(identifier windowHWND, string message, boolean passThrough)
Int JS_WindowMessage_Intercept(void windowHWND, String message, Boolean passThrough)

Begins intercepting a window message type to specified window.

Parameters:
* message: a single message type to be intercepted, either in WM_ or hexadecimal format. For example "WM_SETCURSOR" or "0x0020".
* passThrough: Whether message should be blocked (false) or passed through (true) to the window.
For more information on message codes, refer to the Win32 C++ API documentation.
All WM_ and CB_ message types listed in swell-types.h should be valid cross-platform, and the function can recognize all of these by name. Other messages can be specified by their hex code.

Returns:
* 1: Success.
* 0: The message type is already being intercepted by another script.
* -2: message string could not be parsed.
* -3: Failure getting original window process / window not valid.
* -6: Could not obtain the window client HDC.

Notes:
* Intercepted messages can be polled using JS_WindowMessage_Peek.
* Intercepted messages can be edited, if necessary, and then forwarded to their original destination using JS_WindowMessage_Post or JS_WindowMessage_Send.
* To check whether a message type is being blocked or passed through, Peek the message type, or retrieve the entire List of intercepts.
* Mouse events are typically received by the child window under the mouse, not the parent window.
Keyboard events are usually *not* received by any individual window. To intercept keyboard events, use the VKey functions.

int JS_WindowMessage_InterceptList(void* windowHWND, const char* messages)
int JS_WindowMessage_InterceptList(void* windowHWND, "messages") (requires REAPER 6.24 or later)
int extension_api("JS_WindowMessage_InterceptList", void* windowHWND, "messages") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_WindowMessage_InterceptList(identifier windowHWND, string messages)
Int JS_WindowMessage_InterceptList(void windowHWND, String messages)

Begins intercepting window messages to specified window.

Parameters:
* messages: comma-separated string of message types to be intercepted (either in WM_ or hexadecimal format), each with a "block" or "passthrough" modifier to specify whether the message should be blocked or passed through to the window. For example "WM_SETCURSOR:block, 0x0201:passthrough".
For more information on message codes, refer to the Win32 C++ API documentation.
All WM_ and CB_ message types listed in swell-types.h should be valid cross-platform, and the function can recognize all of these by name. Other messages can be specified by their hex code.

Returns:
* 1: Success.
* 0: The message type is already being intercepted by another script.
* -1: windowHWND is not a valid window.
* -2: message string could not be parsed.
* -3: Failure getting original window process.
* -6: COuld not obtain the window client HDC.

Notes:
* Intercepted messages can be polled using JS_WindowMessage_Peek.
* Intercepted messages can be edited, if necessary, and then forwarded to their original destination using JS_WindowMessage_Post or JS_WindowMessage_Send.
* To check whether a message type is being blocked or passed through, Peek the message type, or retrieve the entire List of intercepts.

bool JS_WindowMessage_ListIntercepts(void* windowHWND, char* listOutNeedBig, int listOutNeedBig_sz)
bool JS_WindowMessage_ListIntercepts(void* windowHWND, #list) (requires REAPER 6.24 or later)
bool extension_api("JS_WindowMessage_ListIntercepts", void* windowHWND, #list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string list = reaper.JS_WindowMessage_ListIntercepts(identifier windowHWND)
(Boolean retval, void windowHWND, String listOutNeedBig, Int listOutNeedBig_sz) = JS_WindowMessage_ListIntercepts(windowHWND, listOutNeedBig, listOutNeedBig_sz)

Returns a string with a list of all message types currently being intercepted for the specified window.

int JS_WindowMessage_PassThrough(void* windowHWND, const char* message, bool passThrough)
int JS_WindowMessage_PassThrough(void* windowHWND, "message", bool passThrough) (requires REAPER 6.24 or later)
int extension_api("JS_WindowMessage_PassThrough", void* windowHWND, "message", bool passThrough) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_WindowMessage_PassThrough(identifier windowHWND, string message, boolean passThrough)
Int JS_WindowMessage_PassThrough(void windowHWND, String message, Boolean passThrough)

Changes the passthrough setting of a message type that is already being intercepted.

Returns 1 if successful, 0 if the message type is not yet being intercepted, or -2 if the argument could not be parsed.

bool JS_WindowMessage_Peek(void* windowHWND, const char* message, bool* passedThroughOut, double* timeOut, int* wParamLowOut, int* wParamHighOut, int* lParamLowOut, int* lParamHighOut)
bool JS_WindowMessage_Peek(void* windowHWND, "message", bool &passedThrough, &time, int &wParamLow, int &wParamHigh, int &lParamLow, int &lParamHigh) (requires REAPER 6.24 or later)
bool extension_api("JS_WindowMessage_Peek", void* windowHWND, "message", bool &passedThrough, &time, int &wParamLow, int &wParamHigh, int &lParamLow, int &lParamHigh) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, boolean passedThrough, number time, integer wParamLow, integer wParamHigh, integer lParamLow, integer lParamHigh = reaper.JS_WindowMessage_Peek(identifier windowHWND, string message)
(Boolean retval, void windowHWND, String message, Boolean passedThroughOut, Float timeOut, Int wParamLowOut, Int wParamHighOut, Int lParamLowOut, Int lParamHighOut) = JS_WindowMessage_Peek(windowHWND, message, passedThroughOut, timeOut, wParamLowOut, wParamHighOut, lParamLowOut, lParamHighOut)

Polls the state of an intercepted message.

Parameters:
* message: String containing a single message name, such as "WM_SETCURSOR", or in hexadecimal format, "0x0020".
(For a list of WM_ and CB_ message types that are valid cross-platform, refer to swell-types.h. Only these will be recognized by WM_ or CB_ name.)

Returns:
* A retval of false indicates that the message type is not being intercepted in the specified window.
* All messages are timestamped. A time of 0 indicates that no message if this type has been intercepted yet.
* For more information about wParam and lParam for different message types, refer to Win32 C++ documentation.
* For example, in the case of mousewheel, returns mousewheel delta, modifier keys, x position and y position.
* wParamHigh, lParamLow and lParamHigh are signed, whereas wParamLow is unsigned.

bool JS_WindowMessage_Post(void* windowHWND, const char* message, double wParam, int wParamHighWord, double lParam, int lParamHighWord)
bool JS_WindowMessage_Post(void* windowHWND, "message", wParam, int wParamHighWord, lParam, int lParamHighWord) (requires REAPER 6.24 or later)
bool extension_api("JS_WindowMessage_Post", void* windowHWND, "message", wParam, int wParamHighWord, lParam, int lParamHighWord) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_WindowMessage_Post(identifier windowHWND, string message, number wParam, integer wParamHighWord, number lParam, integer lParamHighWord)
Boolean JS_WindowMessage_Post(void windowHWND, String message, Float wParam, Int wParamHighWord, Float lParam, Int lParamHighWord)

If the specified window and message type are not currently being intercepted by a script, this function will post the message in the message queue of the specified window, and return without waiting.

If the window and message type are currently being intercepted, the message will be sent directly to the original window process, similar to WindowMessage_Send, thereby skipping any intercepts.

Parameters:
* message: String containing a single message name, such as "WM_SETCURSOR", or in hexadecimal format, "0x0020".
(For a list of WM_ and CB_ message types that are valid cross-platform, refer to swell-types.h. Only these will be recognized by WM_ or CB_ name.)
* wParam, wParamHigh, lParam and lParamHigh: Low and high 16-bit WORDs of the WPARAM and LPARAM parameters.
(Most window messages encode separate information into the two WORDs. However, for those rare cases in which the entire WPARAM and LPARAM must be used to post a large pointer, the script can store this address in wParam or lParam, and keep wParamHigh and lParamHigh zero.)

Notes:
* For more information about parameter values, refer to documentation for the Win32 C++ function PostMessage.
* Messages should only be sent to windows that were created from the main thread.
* Useful for simulating mouse clicks and calling mouse modifier actions from scripts.

int JS_WindowMessage_Release(void* windowHWND, const char* messages)
int JS_WindowMessage_Release(void* windowHWND, "messages") (requires REAPER 6.24 or later)
int extension_api("JS_WindowMessage_Release", void* windowHWND, "messages") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_WindowMessage_Release(identifier windowHWND, string messages)
Int JS_WindowMessage_Release(void windowHWND, String messages)

Release intercepts of specified message types.

Parameters:
* messages: "WM_SETCURSOR,WM_MOUSEHWHEEL" or "0x0020,0x020E", for example.

void JS_WindowMessage_ReleaseAll()
JS_WindowMessage_ReleaseAll() (requires REAPER 6.24 or later)
extension_api("JS_WindowMessage_ReleaseAll") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_WindowMessage_ReleaseAll()
JS_WindowMessage_ReleaseAll()

Release script intercepts of window messages for all windows.

void JS_WindowMessage_ReleaseWindow(void* windowHWND)
JS_WindowMessage_ReleaseWindow(void* windowHWND) (requires REAPER 6.24 or later)
extension_api("JS_WindowMessage_ReleaseWindow", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_WindowMessage_ReleaseWindow(identifier windowHWND)
JS_WindowMessage_ReleaseWindow(void windowHWND)

Release script intercepts of window messages for specified window.

int JS_WindowMessage_Send(void* windowHWND, const char* message, double wParam, int wParamHighWord, double lParam, int lParamHighWord)
int JS_WindowMessage_Send(void* windowHWND, "message", wParam, int wParamHighWord, lParam, int lParamHighWord) (requires REAPER 6.24 or later)
int extension_api("JS_WindowMessage_Send", void* windowHWND, "message", wParam, int wParamHighWord, lParam, int lParamHighWord) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_WindowMessage_Send(identifier windowHWND, string message, number wParam, integer wParamHighWord, number lParam, integer lParamHighWord)
Int JS_WindowMessage_Send(void windowHWND, String message, Float wParam, Int wParamHighWord, Float lParam, Int lParamHighWord)

Sends a message to the specified window by calling the window process directly, and only returns after the message has been processed. Any intercepts of the message by scripts will be skipped, and the message can therefore not be blocked.

Parameters:
* message: String containing a single message name, such as "WM_SETCURSOR", or in hexadecimal format, "0x0020".
(For a list of WM_ and CB_ message types that are valid cross-platform, refer to swell-types.h. Only these will be recognized by WM_ or CB_ name.)
* wParam, wParamHigh, lParam and lParamHigh: Low and high 16-bit WORDs of the WPARAM and LPARAM parameters.
(Most window messages encode separate information into the two WORDs. However, for those rare cases in which the entire WPARAM and LPARAM must be used to post a large pointer, the script can store this address in wParam or lParam, and keep wParamHigh and lParamHigh zero.)

Notes:
* For more information about parameter and return values, refer to documentation for the Win32 C++ function SendMessage.
* Messages should only be sent to windows that were created from the main thread.
* Useful for simulating mouse clicks and calling mouse modifier actions from scripts.

void JS_Window_AddressFromHandle(void* handle, double* addressOut)
JS_Window_AddressFromHandle(void* handle, &address) (requires REAPER 6.24 or later)
extension_api("JS_Window_AddressFromHandle", void* handle, &address) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number address = reaper.JS_Window_AddressFromHandle(identifier handle)
(void handle, Float addressOut) = JS_Window_AddressFromHandle(handle, addressOut)
int JS_Window_ArrayAllChild(void* parentHWND, void* reaperarray)
int JS_Window_ArrayAllChild(void* parentHWND, void* reaperarray) (requires REAPER 6.24 or later)
int extension_api("JS_Window_ArrayAllChild", void* parentHWND, void* reaperarray) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Window_ArrayAllChild(identifier parentHWND, identifier reaperarray)
Int JS_Window_ArrayAllChild(void parentHWND, void reaperarray)

Finds all child windows of the specified parent.

Returns:
* retval: The number of windows found; negative if an error occurred.
* The addresses are stored in the provided reaper.array, and can be converted to REAPER objects (HWNDs) by the function JS_Window_HandleFromAddress.

int JS_Window_ArrayAllTop(void* reaperarray)
int JS_Window_ArrayAllTop(void* reaperarray) (requires REAPER 6.24 or later)
int extension_api("JS_Window_ArrayAllTop", void* reaperarray) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Window_ArrayAllTop(identifier reaperarray)
Int JS_Window_ArrayAllTop(void reaperarray)

Finds all top-level windows.

Returns:
* retval: The number of windows found; negative if an error occurred.
* The addresses are stored in the provided reaper.array, and can be converted to REAPER objects (HWNDs) by the function JS_Window_HandleFromAddress.

int JS_Window_ArrayFind(const char* title, bool exact, void* reaperarray)
int JS_Window_ArrayFind("title", bool exact, void* reaperarray) (requires REAPER 6.24 or later)
int extension_api("JS_Window_ArrayFind", "title", bool exact, void* reaperarray) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Window_ArrayFind(string title, boolean exact, identifier reaperarray)
Int JS_Window_ArrayFind(String title, Boolean exact, void reaperarray)

Finds all windows, whether top-level or child, whose titles match the specified string.

Returns:
* retval: The number of windows found; negative if an error occurred.
* The addresses are stored in the provided reaper.array, and can be converted to REAPER objects (HWNDs) by the function JS_Window_HandleFromAddress.

Parameters:
* exact: Match entire title exactly, or match substring of title.

void JS_Window_AttachResizeGrip(void* windowHWND)
JS_Window_AttachResizeGrip(void* windowHWND) (requires REAPER 6.24 or later)
extension_api("JS_Window_AttachResizeGrip", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_AttachResizeGrip(identifier windowHWND)
JS_Window_AttachResizeGrip(void windowHWND)
void JS_Window_AttachTopmostPin(void* windowHWND)
JS_Window_AttachTopmostPin(void* windowHWND) (requires REAPER 6.24 or later)
extension_api("JS_Window_AttachTopmostPin", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_AttachTopmostPin(identifier windowHWND)
JS_Window_AttachTopmostPin(void windowHWND)

Attaches a "pin on top" button to the window frame. The button should remember its state when closing and re-opening the window.

WARNING: This function does not yet work on Linux.

void JS_Window_ClientToScreen(void* windowHWND, int x, int y, int* xOut, int* yOut)
JS_Window_ClientToScreen(void* windowHWND, int x, int y, int &x, int &y) (requires REAPER 6.24 or later)
extension_api("JS_Window_ClientToScreen", void* windowHWND, int x, int y, int &x, int &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer x, integer y = reaper.JS_Window_ClientToScreen(identifier windowHWND, integer x, integer y)
(void windowHWND, Int x, Int y, Int xOut, Int yOut) = JS_Window_ClientToScreen(windowHWND, x, y, xOut, yOut)

Converts the client-area coordinates of a specified point to screen coordinates.

NOTES:
* On Windows and Linux, screen coordinates are relative to *upper* left corner of the primary display, and the positive Y-axis points downward.
* On macOS, screen coordinates are relative to the *bottom* left corner of the primary display, and the positive Y-axis points upward.
* On all platforms, client coordinates are relative to the upper left corner of the client area.

void* JS_Window_Create(const char* title, const char* className, int x, int y, int w, int h, char* styleOptional, void* ownerHWNDOptional)
void* JS_Window_Create("title", "className", int x, int y, int w, int h, optional #style, void* ownerHWND) (requires REAPER 6.24 or later)
void* extension_api("JS_Window_Create", "title", "className", int x, int y, int w, int h, optional #style, void* ownerHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier retval, optional string style = reaper.JS_Window_Create(string title, string className, integer x, integer y, integer w, integer h, optional string style, identifier ownerHWND)
(void retval, String title, String className, Int x, Int y, Int w, Int h, String styleOptional, void ownerHWNDOptional) = JS_Window_Create(title, className, x, y, w, h, styleOptional, ownerHWNDOptional)

Creates a modeless window with WS_OVERLAPPEDWINDOW style and only rudimentary features. Scripts can paint into the window using GDI or LICE/Composite functions (and JS_Window_InvalidateRect to trigger re-painting).

style: An optional parameter that overrides the default style. The string may include any combination of standard window styles, such as "POPUP" for a frameless window, or "CAPTION,SIZEBOX,SYSMENU" for a standard framed window.

On Linux and macOS, "MAXIMIZE" has not yet been implemented, and the remaining styles may appear slightly different from their WindowsOS counterparts.

className: On Windows, only standard ANSI characters are supported.

ownerHWND: Optional parameter, only available on WindowsOS. Usually either the REAPER main window or another script window, and useful for ensuring that the created window automatically closes when the owner is closed.

NOTE: On Linux and macOS, the window contents are only updated *between* defer cycles, so the window cannot be animated by for/while loops within a single defer cycle.

void JS_Window_Destroy(void* windowHWND)
JS_Window_Destroy(void* windowHWND) (requires REAPER 6.24 or later)
extension_api("JS_Window_Destroy", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_Destroy(identifier windowHWND)
JS_Window_Destroy(void windowHWND)

Destroys the specified window.

void JS_Window_Enable(void* windowHWND, bool enable)
JS_Window_Enable(void* windowHWND, bool enable) (requires REAPER 6.24 or later)
extension_api("JS_Window_Enable", void* windowHWND, bool enable) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_Enable(identifier windowHWND, boolean enable)
JS_Window_Enable(void windowHWND, Boolean enable)

Enables or disables mouse and keyboard input to the specified window or control.

int JS_Window_EnableMetal(void* windowHWND)
int JS_Window_EnableMetal(void* windowHWND) (requires REAPER 6.24 or later)
int extension_api("JS_Window_EnableMetal", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Window_EnableMetal(identifier windowHWND)
Int JS_Window_EnableMetal(void windowHWND)

On macOS, returns the Metal graphics setting:
2 = Metal enabled and support GetDC()/ReleaseDC() for drawing (more overhead).
1 = Metal enabled.
0 = N/A (Windows and Linux).
-1 = non-metal async layered mode.
-2 = non-metal non-async layered mode.

WARNING: If using mode -1, any BitBlt()/StretchBlt() MUST have the source bitmap persist. If it is resized after Blit it could cause crashes.

void* JS_Window_Find(const char* title, bool exact)
void* JS_Window_Find("title", bool exact) (requires REAPER 6.24 or later)
void* extension_api("JS_Window_Find", "title", bool exact) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_Find(string title, boolean exact)
void JS_Window_Find(String title, Boolean exact)

Returns a HWND to a window whose title matches the specified string.
* Unlike the Win32 function FindWindow, this function searches top-level as well as child windows, so that the target window can be found irrespective of docked state.
* In addition, the function can optionally match substrings of the title.
* Matching is not case sensitive.

Parameters:
* exact: Match entire title, or match substring of title.

void* JS_Window_FindChild(void* parentHWND, const char* title, bool exact)
void* JS_Window_FindChild(void* parentHWND, "title", bool exact) (requires REAPER 6.24 or later)
void* extension_api("JS_Window_FindChild", void* parentHWND, "title", bool exact) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_FindChild(identifier parentHWND, string title, boolean exact)
void JS_Window_FindChild(void parentHWND, String title, Boolean exact)

Returns a HWND to a child window whose title matches the specified string.

Parameters:
* exact: Match entire title length, or match substring of title. In both cases, matching is not case sensitive.

void* JS_Window_FindChildByID(void* parentHWND, int ID)
void* JS_Window_FindChildByID(void* parentHWND, int ID) (requires REAPER 6.24 or later)
void* extension_api("JS_Window_FindChildByID", void* parentHWND, int ID) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_FindChildByID(identifier parentHWND, integer ID)
void JS_Window_FindChildByID(void parentHWND, Int ID)

Similar to the C++ WIN32 function GetDlgItem, this function finds child windows by ID.

(The ID of a window may be retrieved by JS_Window_GetLongPtr.)

void* JS_Window_FindEx(void* parentHWND, void* childHWND, const char* className, const char* title)
void* JS_Window_FindEx(void* parentHWND, void* childHWND, "className", "title") (requires REAPER 6.24 or later)
void* extension_api("JS_Window_FindEx", void* parentHWND, void* childHWND, "className", "title") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_FindEx(identifier parentHWND, identifier childHWND, string className, string title)
void JS_Window_FindEx(void parentHWND, void childHWND, String className, String title)

Returns a handle to a child window whose class and title match the specified strings.

Parameters: * childWindow: The function searches child windows, beginning with the window *after* the specified child window. If childHWND is equal to parentHWND, the search begins with the first child window of parentHWND.
* title: An empty string, "", will match all windows. (Search is not case sensitive.)

void* JS_Window_FindTop(const char* title, bool exact)
void* JS_Window_FindTop("title", bool exact) (requires REAPER 6.24 or later)
void* extension_api("JS_Window_FindTop", "title", bool exact) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_FindTop(string title, boolean exact)
void JS_Window_FindTop(String title, Boolean exact)

Returns a HWND to a top-level window whose title matches the specified string.

Parameters:
* exact: Match entire title length, or match substring of title. In both cases, matching is not case sensitive.

void* JS_Window_FromPoint(int x, int y)
void* JS_Window_FromPoint(int x, int y) (requires REAPER 6.24 or later)
void* extension_api("JS_Window_FromPoint", int x, int y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_FromPoint(integer x, integer y)
void JS_Window_FromPoint(Int x, Int y)

Retrieves a HWND to the window that contains the specified point.

NOTES:
* On Windows and Linux, screen coordinates are relative to *upper* left corner of the primary display, and the positive Y-axis points downward.
* On macOS, screen coordinates are relative to the *bottom* left corner of the primary display, and the positive Y-axis points upward.

void JS_Window_GetClassName(void* windowHWND, char* classOut, int classOut_sz)
JS_Window_GetClassName(void* windowHWND, #class) (requires REAPER 6.24 or later)
extension_api("JS_Window_GetClassName", void* windowHWND, #class) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string class = reaper.JS_Window_GetClassName(identifier windowHWND)
(void windowHWND, String classOut, Int classOut_sz) = JS_Window_GetClassName(windowHWND, classOut, classOut_sz)

WARNING: May not be fully implemented on macOS and Linux.

bool JS_Window_GetClientRect(void* windowHWND, int* leftOut, int* topOut, int* rightOut, int* bottomOut)
bool JS_Window_GetClientRect(void* windowHWND, int &left, int &top, int &right, int &bottom) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_GetClientRect", void* windowHWND, int &left, int &top, int &right, int &bottom) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer left, integer top, integer right, integer bottom = reaper.JS_Window_GetClientRect(identifier windowHWND)
(Boolean retval, void windowHWND, Int leftOut, Int topOut, Int rightOut, Int bottomOut) = JS_Window_GetClientRect(windowHWND, leftOut, topOut, rightOut, bottomOut)

Retrieves the screen coordinates of the client area rectangle of the specified window.

NOTES:
* Unlike the C++ function GetClientRect, this function returns the screen coordinates, not the width and height. To get the client size, use GetClientSize.
* The pixel at (right, bottom) lies immediately outside the rectangle.
* On Windows and Linux, screen coordinates are relative to *upper* left corner of the primary display, and the positive Y-axis points downward.
* On macOS, screen coordinates are relative to the *bottom* left corner of the primary display, and the positive Y-axis points upward.

bool JS_Window_GetClientSize(void* windowHWND, int* widthOut, int* heightOut)
bool JS_Window_GetClientSize(void* windowHWND, int &width, int &height) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_GetClientSize", void* windowHWND, int &width, int &height) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer width, integer height = reaper.JS_Window_GetClientSize(identifier windowHWND)
(Boolean retval, void windowHWND, Int widthOut, Int heightOut) = JS_Window_GetClientSize(windowHWND, widthOut, heightOut)
void* JS_Window_GetFocus()
void* JS_Window_GetFocus() (requires REAPER 6.24 or later)
void* extension_api("JS_Window_GetFocus") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_GetFocus()
void JS_Window_GetFocus()

Retrieves a HWND to the window that has the keyboard focus, if the window is attached to the calling thread's message queue.

void* JS_Window_GetForeground()
void* JS_Window_GetForeground() (requires REAPER 6.24 or later)
void* extension_api("JS_Window_GetForeground") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_GetForeground()
void JS_Window_GetForeground()

Retrieves a HWND to the top-level foreground window (the window with which the user is currently working).

void JS_Window_GetLong(void* windowHWND, const char* info, double* retvalOut)
JS_Window_GetLong(void* windowHWND, "info", &retval) (requires REAPER 6.24 or later)
extension_api("JS_Window_GetLong", void* windowHWND, "info", &retval) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number retval = reaper.JS_Window_GetLong(identifier windowHWND, string info)
(void windowHWND, String info, Float retvalOut) = JS_Window_GetLong(windowHWND, info, retvalOut)

Similar to JS_Window_GetLongPtr, but returns the information as a number instead of a pointer.

In the case of "DLGPROC" and "WNDPROC", the return values can be converted to pointers by JS_Window_HandleFromAddress.

If the function fails, the return value is 0.

void* JS_Window_GetLongPtr(void* windowHWND, const char* info)
void* JS_Window_GetLongPtr(void* windowHWND, "info") (requires REAPER 6.24 or later)
void* extension_api("JS_Window_GetLongPtr", void* windowHWND, "info") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_GetLongPtr(identifier windowHWND, string info)
void JS_Window_GetLongPtr(void windowHWND, String info)

Returns information about the specified window.

info: "USERDATA", "WNDPROC", "DLGPROC", "ID", "EXSTYLE" or "STYLE".

For documentation about the types of information returned, refer to the Win32 function GetWindowLongPtr.

The values returned by "DLGPROC" and "WNDPROC" are typically used as-is, as pointers, whereas the others should first be converted to integers.

If the function fails, a null pointer is returned.

void* JS_Window_GetParent(void* windowHWND)
void* JS_Window_GetParent(void* windowHWND) (requires REAPER 6.24 or later)
void* extension_api("JS_Window_GetParent", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_GetParent(identifier windowHWND)
void JS_Window_GetParent(void windowHWND)

Retrieves a HWND to the specified window's parent or owner.
Returns NULL if the window is unowned or if the function otherwise fails.

bool JS_Window_GetRect(void* windowHWND, int* leftOut, int* topOut, int* rightOut, int* bottomOut)
bool JS_Window_GetRect(void* windowHWND, int &left, int &top, int &right, int &bottom) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_GetRect", void* windowHWND, int &left, int &top, int &right, int &bottom) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer left, integer top, integer right, integer bottom = reaper.JS_Window_GetRect(identifier windowHWND)
(Boolean retval, void windowHWND, Int leftOut, Int topOut, Int rightOut, Int bottomOut) = JS_Window_GetRect(windowHWND, leftOut, topOut, rightOut, bottomOut)

Retrieves the screen coordinates of the bounding rectangle of the specified window.

NOTES:
* On Windows and Linux, coordinates are relative to *upper* left corner of the primary display, and the positive Y-axis points downward.
* On macOS, coordinates are relative to the *bottom* left corner of the primary display, and the positive Y-axis points upward.
* The pixel at (right, bottom) lies immediately outside the rectangle.

void* JS_Window_GetRelated(void* windowHWND, const char* relation)
void* JS_Window_GetRelated(void* windowHWND, "relation") (requires REAPER 6.24 or later)
void* extension_api("JS_Window_GetRelated", void* windowHWND, "relation") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_GetRelated(identifier windowHWND, string relation)
void JS_Window_GetRelated(void windowHWND, String relation)

Retrieves a handle to a window that has the specified relationship (Z-Order or owner) to the specified window.
relation: "LAST", "NEXT", "PREV", "OWNER" or "CHILD".
(Refer to documentation for Win32 C++ function GetWindow.)

bool JS_Window_GetScrollInfo(void* windowHWND, const char* scrollbar, int* positionOut, int* pageSizeOut, int* minOut, int* maxOut, int* trackPosOut)
bool JS_Window_GetScrollInfo(void* windowHWND, "scrollbar", int &position, int &pageSize, int &min, int &max, int &trackPos) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_GetScrollInfo", void* windowHWND, "scrollbar", int &position, int &pageSize, int &min, int &max, int &trackPos) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer position, integer pageSize, integer min, integer max, integer trackPos = reaper.JS_Window_GetScrollInfo(identifier windowHWND, string scrollbar)
(Boolean retval, void windowHWND, String scrollbar, Int positionOut, Int pageSizeOut, Int minOut, Int maxOut, Int trackPosOut) = JS_Window_GetScrollInfo(windowHWND, scrollbar, positionOut, pageSizeOut, minOut, maxOut, trackPosOut)

Retrieves the scroll information of a window.

Parameters:
* windowHWND: The window that contains the scrollbar. This is usually a child window, not a top-level, framed window.
* scrollbar: "v" (or "SB_VERT", or "VERT") for vertical scroll, "h" (or "SB_HORZ" or "HORZ") for horizontal.

Returns:
* Leftmost or topmost visible pixel position, as well as the visible page size, the range minimum and maximum, and scroll box tracking position.

void JS_Window_GetTitle(void* windowHWND, char* titleOutNeedBig, int titleOutNeedBig_sz)
JS_Window_GetTitle(void* windowHWND, #title) (requires REAPER 6.24 or later)
extension_api("JS_Window_GetTitle", void* windowHWND, #title) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string title = reaper.JS_Window_GetTitle(identifier windowHWND)
(void windowHWND, String titleOutNeedBig, Int titleOutNeedBig_sz) = JS_Window_GetTitle(windowHWND, titleOutNeedBig, titleOutNeedBig_sz)

Returns the title (if any) of the specified window.

void JS_Window_GetViewportFromRect(int x1, int y1, int x2, int y2, bool wantWork, int* leftOut, int* topOut, int* rightOut, int* bottomOut)
JS_Window_GetViewportFromRect(int x1, int y1, int x2, int y2, bool wantWork, int &left, int &top, int &right, int &bottom) (requires REAPER 6.24 or later)
extension_api("JS_Window_GetViewportFromRect", int x1, int y1, int x2, int y2, bool wantWork, int &left, int &top, int &right, int &bottom) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer left, integer top, integer right, integer bottom = reaper.JS_Window_GetViewportFromRect(integer x1, integer y1, integer x2, integer y2, boolean wantWork)
(Int x1, Int y1, Int x2, Int y2, Boolean wantWork, Int leftOut, Int topOut, Int rightOut, Int bottomOut) = JS_Window_GetViewportFromRect(x1, y1, x2, y2, wantWork, leftOut, topOut, rightOut, bottomOut)

Retrieves the dimensions of the display monitor that has the largest area of intersection with the specified rectangle.

If the monitor is not the primary display, some of the rectangle's coordinates may be negative.

wantWork: Returns the work area of the display, which excludes the system taskbar or application desktop toolbars.

void* JS_Window_HandleFromAddress(double address)
void* JS_Window_HandleFromAddress(address) (requires REAPER 6.24 or later)
void* extension_api("JS_Window_HandleFromAddress", address) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_HandleFromAddress(number address)
void JS_Window_HandleFromAddress(Float address)

Converts an address to a handle (such as a HWND) that can be utilized by REAPER and other API functions.

bool JS_Window_InvalidateRect(void* windowHWND, int left, int top, int right, int bottom, bool eraseBackground)
bool JS_Window_InvalidateRect(void* windowHWND, int left, int top, int right, int bottom, bool eraseBackground) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_InvalidateRect", void* windowHWND, int left, int top, int right, int bottom, bool eraseBackground) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Window_InvalidateRect(identifier windowHWND, integer left, integer top, integer right, integer bottom, boolean eraseBackground)
Boolean JS_Window_InvalidateRect(void windowHWND, Int left, Int top, Int right, Int bottom, Boolean eraseBackground)

Similar to the Win32 function InvalidateRect.

bool JS_Window_IsChild(void* parentHWND, void* childHWND)
bool JS_Window_IsChild(void* parentHWND, void* childHWND) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_IsChild", void* parentHWND, void* childHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Window_IsChild(identifier parentHWND, identifier childHWND)
Boolean JS_Window_IsChild(void parentHWND, void childHWND)

Determines whether a window is a child window or descendant window of a specified parent window.

bool JS_Window_IsVisible(void* windowHWND)
bool JS_Window_IsVisible(void* windowHWND) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_IsVisible", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Window_IsVisible(identifier windowHWND)
Boolean JS_Window_IsVisible(void windowHWND)

Determines the visibility state of the window.

bool JS_Window_IsWindow(void* windowHWND)
bool JS_Window_IsWindow(void* windowHWND) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_IsWindow", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Window_IsWindow(identifier windowHWND)
Boolean JS_Window_IsWindow(void windowHWND)

Determines whether the specified window handle identifies an existing window.

On macOS and Linux, only windows that were created by WDL/swell will be identified (and only such windows should be acted on by scripts).

NOTE: Since REAPER v5.974, windows can be checked using the native function ValidatePtr(windowHWND, "HWND").

int JS_Window_ListAllChild(void* parentHWND, char* listOutNeedBig, int listOutNeedBig_sz)
int JS_Window_ListAllChild(void* parentHWND, #list) (requires REAPER 6.24 or later)
int extension_api("JS_Window_ListAllChild", void* parentHWND, #list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string list = reaper.JS_Window_ListAllChild(identifier parentHWND)
(Int retval, void parentHWND, String listOutNeedBig, Int listOutNeedBig_sz) = JS_Window_ListAllChild(parentHWND, listOutNeedBig, listOutNeedBig_sz)

Finds all child windows of the specified parent.

Returns:
* retval: The number of windows found; negative if an error occurred.
* list: A comma-separated string of hexadecimal values.
Each value is an address that can be converted to a HWND by the function Window_HandleFromAddress.

int JS_Window_ListAllTop(char* listOutNeedBig, int listOutNeedBig_sz)
int JS_Window_ListAllTop(#list) (requires REAPER 6.24 or later)
int extension_api("JS_Window_ListAllTop", #list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string list = reaper.JS_Window_ListAllTop()
(Int retval, String listOutNeedBig, Int listOutNeedBig_sz) = JS_Window_ListAllTop(listOutNeedBig, listOutNeedBig_sz)

Finds all top-level windows.

Returns:
* retval: The number of windows found; negative if an error occurred.
* list: A comma-separated string of hexadecimal values. Each value is an address that can be converted to a HWND by the function Window_HandleFromAddress.

int JS_Window_ListFind(const char* title, bool exact, char* listOutNeedBig, int listOutNeedBig_sz)
int JS_Window_ListFind("title", bool exact, #list) (requires REAPER 6.24 or later)
int extension_api("JS_Window_ListFind", "title", bool exact, #list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string list = reaper.JS_Window_ListFind(string title, boolean exact)
(Int retval, String title, Boolean exact, String listOutNeedBig, Int listOutNeedBig_sz) = JS_Window_ListFind(title, exact, listOutNeedBig, listOutNeedBig_sz)

Finds all windows (whether top-level or child) whose titles match the specified string.

Returns:
* retval: The number of windows found; negative if an error occurred.
* list: A comma-separated string of hexadecimal values. Each value is an address that can be converted to a HWND by the function Window_HandleFromAddress.

Parameters:
* exact: Match entire title exactly, or match substring of title.

void JS_Window_MonitorFromRect(int x1, int y1, int x2, int y2, bool wantWork, int* leftOut, int* topOut, int* rightOut, int* bottomOut)
JS_Window_MonitorFromRect(int x1, int y1, int x2, int y2, bool wantWork, int &left, int &top, int &right, int &bottom) (requires REAPER 6.24 or later)
extension_api("JS_Window_MonitorFromRect", int x1, int y1, int x2, int y2, bool wantWork, int &left, int &top, int &right, int &bottom) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer left, integer top, integer right, integer bottom = reaper.JS_Window_MonitorFromRect(integer x1, integer y1, integer x2, integer y2, boolean wantWork)
(Int x1, Int y1, Int x2, Int y2, Boolean wantWork, Int leftOut, Int topOut, Int rightOut, Int bottomOut) = JS_Window_MonitorFromRect(x1, y1, x2, y2, wantWork, leftOut, topOut, rightOut, bottomOut)

Deprecated - use GetViewportFromRect instead.

void JS_Window_Move(void* windowHWND, int left, int top)
JS_Window_Move(void* windowHWND, int left, int top) (requires REAPER 6.24 or later)
extension_api("JS_Window_Move", void* windowHWND, int left, int top) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_Move(identifier windowHWND, integer left, integer top)
JS_Window_Move(void windowHWND, Int left, Int top)

Changes the position of the specified window, keeping its size constant.

NOTES:
* For top-level windows, position is relative to the primary display.
* On Windows and Linux, position is calculated as the coordinates of the upper left corner of the window, relative to upper left corner of the primary display, and the positive Y-axis points downward.
* On macOS, position is calculated as the coordinates of the bottom left corner of the window, relative to bottom left corner of the display, and the positive Y-axis points upward.
* For a child window, on all platforms, position is relative to the upper-left corner of the parent window's client area.
* Equivalent to calling JS_Window_SetPosition with NOSIZE, NOZORDER, NOACTIVATE and NOOWNERZORDER flags set.

bool JS_Window_OnCommand(void* windowHWND, int commandID)
bool JS_Window_OnCommand(void* windowHWND, int commandID) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_OnCommand", void* windowHWND, int commandID) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Window_OnCommand(identifier windowHWND, integer commandID)
Boolean JS_Window_OnCommand(void windowHWND, Int commandID)

Sends a "WM_COMMAND" message to the specified window, which simulates a user selecting a command in the window menu.

This function is similar to Main_OnCommand and MIDIEditor_OnCommand, but can send commands to any window that has a menu.

In the case of windows that are listed among the Action list's contexts (such as the Media Explorer), the commandIDs of the actions in the Actions list may be used.

void JS_Window_Resize(void* windowHWND, int width, int height)
JS_Window_Resize(void* windowHWND, int width, int height) (requires REAPER 6.24 or later)
extension_api("JS_Window_Resize", void* windowHWND, int width, int height) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_Resize(identifier windowHWND, integer width, integer height)
JS_Window_Resize(void windowHWND, Int width, Int height)

Changes the dimensions of the specified window, keeping the top left corner position constant.
* If resizing script GUIs, call gfx.update() after resizing.
* Equivalent to calling JS_Window_SetPosition with NOMOVE, NOZORDER, NOACTIVATE and NOOWNERZORDER flags set.

void JS_Window_ScreenToClient(void* windowHWND, int x, int y, int* xOut, int* yOut)
JS_Window_ScreenToClient(void* windowHWND, int x, int y, int &x, int &y) (requires REAPER 6.24 or later)
extension_api("JS_Window_ScreenToClient", void* windowHWND, int x, int y, int &x, int &y) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer x, integer y = reaper.JS_Window_ScreenToClient(identifier windowHWND, integer x, integer y)
(void windowHWND, Int x, Int y, Int xOut, Int yOut) = JS_Window_ScreenToClient(windowHWND, x, y, xOut, yOut)

Converts the screen coordinates of a specified point on the screen to client-area coordinates.

NOTES:
* On Windows and Linux, screen coordinates are relative to *upper* left corner of the primary display, and the positive Y-axis points downward.
* On macOS, screen coordinates are relative to the *bottom* left corner of the primary display, and the positive Y-axis points upward.
* On all platforms, client coordinates are relative to the upper left corner of the client area.

void JS_Window_SetFocus(void* windowHWND)
JS_Window_SetFocus(void* windowHWND) (requires REAPER 6.24 or later)
extension_api("JS_Window_SetFocus", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_SetFocus(identifier windowHWND)
JS_Window_SetFocus(void windowHWND)

Sets the keyboard focus to the specified window.

void JS_Window_SetForeground(void* windowHWND)
JS_Window_SetForeground(void* windowHWND) (requires REAPER 6.24 or later)
extension_api("JS_Window_SetForeground", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_SetForeground(identifier windowHWND)
JS_Window_SetForeground(void windowHWND)

Brings the specified window into the foreground, activates the window, and directs keyboard input to it.

void JS_Window_SetLong(void* windowHWND, const char* info, double value, double* retvalOut)
JS_Window_SetLong(void* windowHWND, "info", value, &retval) (requires REAPER 6.24 or later)
extension_api("JS_Window_SetLong", void* windowHWND, "info", value, &retval) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number retval = reaper.JS_Window_SetLong(identifier windowHWND, string info, number value)
(void windowHWND, String info, Float value, Float retvalOut) = JS_Window_SetLong(windowHWND, info, value, retvalOut)

Similar to the Win32 function SetWindowLongPtr.

info: "USERDATA", "WNDPROC", "DLGPROC", "ID", "EXSTYLE" or "STYLE", and only on WindowOS, "INSTANCE" and "PARENT".

bool JS_Window_SetOpacity(void* windowHWND, const char* mode, double value)
bool JS_Window_SetOpacity(void* windowHWND, "mode", value) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_SetOpacity", void* windowHWND, "mode", value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Window_SetOpacity(identifier windowHWND, string mode, number value)
Boolean JS_Window_SetOpacity(void windowHWND, String mode, Float value)

Sets the window opacity.

Parameters:
mode: either "ALPHA" or "COLOR".
value: If ALPHA, the specified value may range from zero to one, and will apply to the entire window, frame included.
If COLOR, value specifies a 0xRRGGBB color, and all pixels of this color will be made transparent. (All mouse clicks over transparent pixels will pass through, too). WARNING:
COLOR mode is only available in Windows, not Linux or macOS.

Transparency can only be applied to top-level windows. If windowHWND refers to a child window, the entire top-level window that contains windowHWND will be made transparent.

void* JS_Window_SetParent(void* childHWND, void* parentHWNDOptional)
void* JS_Window_SetParent(void* childHWND, void* parentHWND) (requires REAPER 6.24 or later)
void* extension_api("JS_Window_SetParent", void* childHWND, void* parentHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier reaper.JS_Window_SetParent(identifier childHWND, identifier parentHWND)
void JS_Window_SetParent(void childHWND, void parentHWNDOptional)

If successful, returns a handle to the previous parent window.

Only on WindowsOS: If parentHWND is not specified, the desktop window becomes the new parent window.

bool JS_Window_SetPosition(void* windowHWND, int left, int top, int width, int height, char* ZOrderOptional, char* flagsOptional)
bool JS_Window_SetPosition(void* windowHWND, int left, int top, int width, int height, optional #ZOrder, optional #flags) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_SetPosition", void* windowHWND, int left, int top, int width, int height, optional #ZOrder, optional #flags) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, optional string ZOrder, optional string flags = reaper.JS_Window_SetPosition(identifier windowHWND, integer left, integer top, integer width, integer height, optional string ZOrder, optional string flags)
(Boolean retval, void windowHWND, Int left, Int top, Int width, Int height, String ZOrderOptional, String flagsOptional) = JS_Window_SetPosition(windowHWND, left, top, width, height, ZOrderOptional, flagsOptional)

Interface to the Win32/swell function SetWindowPos, with which window position, size, Z-order and visibility can be set, and new frame styles can be applied.

ZOrder and flags are optional parameters. If no arguments are supplied, the window will simply be moved and resized, as if the NOACTIVATE, NOZORDER, NOOWNERZORDER flags were set.
* ZOrder: "BOTTOM", "TOPMOST", "NOTOPMOST", "TOP" or a window HWND converted to a string, for example by the Lua function tostring.
* flags: Any combination of the standard flags, of which "NOMOVE", "NOSIZE", "NOZORDER", "NOACTIVATE", "SHOWWINDOW", "FRAMECHANGED" and "NOCOPYBITS" should be valid cross-platform.

bool JS_Window_SetScrollPos(void* windowHWND, const char* scrollbar, int position)
bool JS_Window_SetScrollPos(void* windowHWND, "scrollbar", int position) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_SetScrollPos", void* windowHWND, "scrollbar", int position) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Window_SetScrollPos(identifier windowHWND, string scrollbar, integer position)
Boolean JS_Window_SetScrollPos(void windowHWND, String scrollbar, Int position)

Parameters:
* scrollbar: "v" (or "SB_VERT", or "VERT") for vertical scroll, "h" (or "SB_HORZ" or "HORZ") for horizontal.

NOTE: API functions can scroll REAPER's windows, but cannot zoom them. Instead, use actions such as "View: Zoom to one loop iteration".

bool JS_Window_SetStyle(void* windowHWND, char* style)
bool JS_Window_SetStyle(void* windowHWND, #style) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_SetStyle", void* windowHWND, #style) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string style = reaper.JS_Window_SetStyle(identifier windowHWND, string style)
(Boolean retval, void windowHWND, String style) = JS_Window_SetStyle(windowHWND, style)

Sets and applies a window style.

style may include any combination of standard window styles, such as "POPUP" for a frameless window, or "CAPTION,SIZEBOX,SYSMENU" for a standard framed window.

On Linux and macOS, "MAXIMIZE" has not yet been implmented, and the remaining styles may appear slightly different from their WindowsOS counterparts.

bool JS_Window_SetTitle(void* windowHWND, const char* title)
bool JS_Window_SetTitle(void* windowHWND, "title") (requires REAPER 6.24 or later)
bool extension_api("JS_Window_SetTitle", void* windowHWND, "title") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Window_SetTitle(identifier windowHWND, string title)
Boolean JS_Window_SetTitle(void windowHWND, String title)

Changes the title of the specified window. Returns true if successful.

bool JS_Window_SetZOrder(void* windowHWND, const char* ZOrder, void* insertAfterHWNDOptional)
bool JS_Window_SetZOrder(void* windowHWND, "ZOrder", void* insertAfterHWND) (requires REAPER 6.24 or later)
bool extension_api("JS_Window_SetZOrder", void* windowHWND, "ZOrder", void* insertAfterHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.JS_Window_SetZOrder(identifier windowHWND, string ZOrder, identifier insertAfterHWND)
Boolean JS_Window_SetZOrder(void windowHWND, String ZOrder, void insertAfterHWNDOptional)

Sets the window Z order.
* Equivalent to calling JS_Window_SetPos with flags NOMOVE | NOSIZE.
* Not all the Z orders have been implemented in Linux yet.

Parameters:
* ZOrder: "BOTTOM", "TOPMOST", "NOTOPMOST", "TOP", or a window HWND converted to a string, for example by the Lua function tostring.

* InsertAfterHWND: For compatibility with older versions, this parameter is still available, and is optional. If ZOrder is "INSERTAFTER", insertAfterHWND must be a handle to the window behind which windowHWND will be placed in the Z order, equivalent to setting ZOrder to this HWND; otherwise, insertAfterHWND is ignored and can be left out (or it can simply be set to the same value as windowHWND).

void JS_Window_Show(void* windowHWND, const char* state)
JS_Window_Show(void* windowHWND, "state") (requires REAPER 6.24 or later)
extension_api("JS_Window_Show", void* windowHWND, "state") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_Show(identifier windowHWND, string state)
JS_Window_Show(void windowHWND, String state)

Sets the specified window's show state.

Parameters:
* state: One of the following options: "SHOW", "SHOWNA" (or "SHOWNOACTIVATE"), "SHOWMINIMIZED", "HIDE", "NORMAL", "SHOWNORMAL", "SHOWMAXIMIZED", "SHOWDEFAULT" or "RESTORE". On Linux and macOS, only the first four options are fully implemented.

void JS_Window_Update(void* windowHWND)
JS_Window_Update(void* windowHWND) (requires REAPER 6.24 or later)
extension_api("JS_Window_Update", void* windowHWND) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.JS_Window_Update(identifier windowHWND)
JS_Window_Update(void windowHWND)

Similar to the Win32 function UpdateWindow.

int JS_Zip_Close(const char* zipFile, void* zipHandleOptional)
int JS_Zip_Close("zipFile", void* zipHandle) (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Close", "zipFile", void* zipHandle) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_Close(string zipFile, identifier zipHandle)
Int JS_Zip_Close(String zipFile, void zipHandleOptional)

Closes the zip archive, using either the file name or the zip handle. Finalizes entries and releases resources.

int JS_Zip_CountEntries(void* zipHandle)
int JS_Zip_CountEntries(void* zipHandle) (requires REAPER 6.24 or later)
int extension_api("JS_Zip_CountEntries", void* zipHandle) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_CountEntries(identifier zipHandle)
Int JS_Zip_CountEntries(void zipHandle)
int JS_Zip_DeleteEntries(void* zipHandle, const char* entryNames, int entryNamesStrLen)
int JS_Zip_DeleteEntries(void* zipHandle, "entryNames", int entryNamesStrLen) (requires REAPER 6.24 or later)
int extension_api("JS_Zip_DeleteEntries", void* zipHandle, "entryNames", int entryNamesStrLen) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_DeleteEntries(identifier zipHandle, string entryNames, integer entryNamesStrLen)
Int JS_Zip_DeleteEntries(void zipHandle, String entryNames, Int entryNamesStrLen)

Deletes the specified entries from an existing Zip file.

entryNames is zero-separated and double-zero-terminated.

Returns the number of deleted entries on success, negative number (< 0) on error.

int JS_Zip_Entry_Close(void* zipHandle)
int JS_Zip_Entry_Close(void* zipHandle) (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Entry_Close", void* zipHandle) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_Entry_Close(identifier zipHandle)
Int JS_Zip_Entry_Close(void zipHandle)

Closes a zip entry, flushes buffer and releases resources. In WRITE mode, entries must be closed in order to apply and save changes.

Returns 0 on success, negative number (< 0) on error.

int JS_Zip_Entry_CompressFile(void* zipHandle, const char* inputFile)
int JS_Zip_Entry_CompressFile(void* zipHandle, "inputFile") (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Entry_CompressFile", void* zipHandle, "inputFile") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_Entry_CompressFile(identifier zipHandle, string inputFile)
Int JS_Zip_Entry_CompressFile(void zipHandle, String inputFile)

Compresses the specified file into the zip archive's open entry.

Returns 0 on success, negative number (< 0) on error.

int JS_Zip_Entry_CompressMemory(void* zipHandle, const char* buf, int buf_size)
int JS_Zip_Entry_CompressMemory(void* zipHandle, "buf", int buf_size) (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Entry_CompressMemory", void* zipHandle, "buf", int buf_size) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_Entry_CompressMemory(identifier zipHandle, string buf, integer buf_size)
Int JS_Zip_Entry_CompressMemory(void zipHandle, String buf, Int buf_size)

Compresses the specified memory buffer into the zip archive's open entry.

Returns 0 on success, negative number (< 0) on error.

int JS_Zip_Entry_ExtractToFile(void* zipHandle, const char* outputFile)
int JS_Zip_Entry_ExtractToFile(void* zipHandle, "outputFile") (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Entry_ExtractToFile", void* zipHandle, "outputFile") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_Entry_ExtractToFile(identifier zipHandle, string outputFile)
Int JS_Zip_Entry_ExtractToFile(void zipHandle, String outputFile)

Extracts the zip archive's open entry.

Returns 0 on success, negative number (< 0) on error.

int JS_Zip_Entry_ExtractToMemory(void* zipHandle, char* contentsOutNeedBig, int contentsOutNeedBig_sz)
int JS_Zip_Entry_ExtractToMemory(void* zipHandle, #contents) (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Entry_ExtractToMemory", void* zipHandle, #contents) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string contents = reaper.JS_Zip_Entry_ExtractToMemory(identifier zipHandle)
(Int retval, void zipHandle, String contentsOutNeedBig, Int contentsOutNeedBig_sz) = JS_Zip_Entry_ExtractToMemory(zipHandle, contentsOutNeedBig, contentsOutNeedBig_sz)

Extracts and returns the zip archive's open entry.

Returns the number of bytes extracted on success, negative number (< 0) on error.

int JS_Zip_Entry_Info(void* zipHandle, char* nameOutNeedBig, int nameOutNeedBig_sz, int* indexOut, int* isFolderOut, double* sizeOut, double* crc32Out)
int JS_Zip_Entry_Info(void* zipHandle, #name, int &index, int &isFolder, &size, &crc32) (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Entry_Info", void* zipHandle, #name, int &index, int &isFolder, &size, &crc32) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string name, integer index, integer isFolder, number size, number crc32 = reaper.JS_Zip_Entry_Info(identifier zipHandle)
(Int retval, void zipHandle, String nameOutNeedBig, Int nameOutNeedBig_sz, Int indexOut, Int isFolderOut, Float sizeOut, Float crc32Out) = JS_Zip_Entry_Info(zipHandle, nameOutNeedBig, nameOutNeedBig_sz, indexOut, isFolderOut, sizeOut, crc32Out)

Returns information about the zip archive's open entry.

int JS_Zip_Entry_OpenByIndex(void* zipHandle, int index)
int JS_Zip_Entry_OpenByIndex(void* zipHandle, int index) (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Entry_OpenByIndex", void* zipHandle, int index) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_Entry_OpenByIndex(identifier zipHandle, integer index)
Int JS_Zip_Entry_OpenByIndex(void zipHandle, Int index)

Opens a new entry by index in the zip archive.

This function is only valid if zip archive was opened in 'r' (readonly) mode.

Returns 0 on success, negative number on error.

int JS_Zip_Entry_OpenByName(void* zipHandle, const char* entryName)
int JS_Zip_Entry_OpenByName(void* zipHandle, "entryName") (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Entry_OpenByName", void* zipHandle, "entryName") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_Entry_OpenByName(identifier zipHandle, string entryName)
Int JS_Zip_Entry_OpenByName(void zipHandle, String entryName)

Opens an entry by name in the zip archive.

For zip archive opened in 'w' or 'a' mode the function will append a new entry. In readonly mode the function tries to locate an existing entry.

Returns 0 on success, negative number (< 0) on error.

void JS_Zip_ErrorString(int errorNum, char* errorStrOut, int errorStrOut_sz)
JS_Zip_ErrorString(int errorNum, #errorStr) (requires REAPER 6.24 or later)
extension_api("JS_Zip_ErrorString", int errorNum, #errorStr) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string errorStr = reaper.JS_Zip_ErrorString(integer errorNum)
(Int errorNum, String errorStrOut, Int errorStrOut_sz) = JS_Zip_ErrorString(errorNum, errorStrOut, errorStrOut_sz)

Returns a descriptive string for the given error code.

int JS_Zip_Extract(const char* zipFile, const char* outputFolder)
int JS_Zip_Extract("zipFile", "outputFolder") (requires REAPER 6.24 or later)
int extension_api("JS_Zip_Extract", "zipFile", "outputFolder") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.JS_Zip_Extract(string zipFile, string outputFolder)
Int JS_Zip_Extract(String zipFile, String outputFolder)

Extracts an existing Zip file to the specified folder.

Returns the number of extracted files on success, negative number (< 0) on error.

int JS_Zip_ListAllEntries(void* zipHandle, char* listOutNeedBig, int listOutNeedBig_sz)
int JS_Zip_ListAllEntries(void* zipHandle, #list) (requires REAPER 6.24 or later)
int extension_api("JS_Zip_ListAllEntries", void* zipHandle, #list) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string list = reaper.JS_Zip_ListAllEntries(identifier zipHandle)
(Int retval, void zipHandle, String listOutNeedBig, Int listOutNeedBig_sz) = JS_Zip_ListAllEntries(zipHandle, listOutNeedBig, listOutNeedBig_sz)

Returns the number of entries and a zero-separated and double-zero-terminated string of entry names.

On error, returns a negative number (< 0).

void* JS_Zip_Open(const char* zipFile, const char* mode, int compressionLevel, int* retvalOut)
void* JS_Zip_Open("zipFile", "mode", int compressionLevel, int &retval) (requires REAPER 6.24 or later)
void* extension_api("JS_Zip_Open", "zipFile", "mode", int compressionLevel, int &retval) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
identifier retval, integer retval = reaper.JS_Zip_Open(string zipFile, string mode, integer compressionLevel)
(void retval, String zipFile, String mode, Int compressionLevel, Int retvalOut) = JS_Zip_Open(zipFile, mode, compressionLevel, retvalOut)

Opens a zip archive using the given mode, which can be either "READ" or "WRITE" (or simply 'r' or 'w').

* READ: Opens an existing archive for reading/extracting.
* WRITE: Opens an archive for writing/deleting. If the file doesn't exist, an empty archive will created.

compressionLevel is only relevant for WRITE mode, and ranges from 0 (fastest, no compression) to 9 (slowest, best compression), with a default of 6.

If successful, returns 0 and a handle to the Zip archive. If failed, returns a negative error code. If the file is already open -- in the given mode -- the existing handle will be returned.

NOTES:
* The Zip API functions support Unicode file names and entry names.
* The original zip specification did not support Unicode. Some applications still use this outdated specification by default, or try to use the local code page. This may lead to incompatibility and incorrect retrieval of file or entry names.

void Llm_Do(int* paramInOptional)
Llm_Do(optional int paramIn) (requires REAPER 6.24 or later)
extension_api("Llm_Do", optional int paramIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.Llm_Do(optional integer paramIn)
(Int paramInOptional) Llm_Do(paramInOptional)

Called with parameter value 1 executes one ReaLlm cycle. E.g. for running ReaLlm on custom timer, or deferred. 0 or nothing performs shutdown. Disarming/disabling all monitored inputs and calling with parameter value 1 equals to shutdown.

void Llm_Get(const char* parmname, char* bufOutNeedBig, int bufOutNeedBig_sz, MediaTrack* trInOptional)
Llm_Get("parmname", #buf, MediaTrack trIn) (requires REAPER 6.24 or later)
extension_api("Llm_Get", "parmname", #buf, MediaTrack trIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string buf = reaper.Llm_Get(string parmname, string buf, MediaTrack trIn)
(String parmname, String bufOutNeedBig, Int bufOutNeedBig_sz, MediaTrack trInOptional) = Llm_Get(parmname, bufOutNeedBig, bufOutNeedBig_sz, trInOptional)

Get ReaLlm information string. Zero-based indices. Master track index -1. Optional MediaTrack* tr gets results relative to tr. Each line (newline '\n' separated) represents entry. Tracks are separated with ';'. FX are listed after ':' separated with ','.
GRAPH : Mixer routings as network graph in format "node;neighborhood\n" where node is track, and neighborhood is group of tracks in format "track;tr#1;tr#2...\n". Or as "parent;children\n" where first field is parent and rest are children. Or as multiply linked list where first field is node and rest are links. E.g. "7;1;-1;\n" would mean "8th track is connected to 2nd track and Master track."
PDCLATENCY : Latency in samples.
PDCLIMIT : Limit in samples.
REALLM or STATE : Current state of ReaLlm as approach vektors with disabled FX in format: "begin:disabled fx,...;next:fx,...;end:fx,...;\n." E.g. "3:1,2;0;-1:0\n" would be: 4th track, fx#2 and #3 disabled => 1st track, nofx disabled => Master track, fx#1 disabled.
SAFE : 'Safed' plugins as "track#:fx#\n" pairs.
VECTOR : Same as REALLM without FX information. Faster.

void Llm_Set(const char* parmname, const char* bufIn)
Llm_Set("parmname", "bufIn") (requires REAPER 6.24 or later)
extension_api("Llm_Set", "parmname", "bufIn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.Llm_Set(string parmname, string bufIn)
Llm_Set(String parmname, String bufIn)

Set ReaLlm parameters.
PDCLIMIT : PDC latency limit in audio blocks/buffers, e.g. "1.5".
MONITORINGFX : Use any non-empty string to include Monitoring FX. E.g. "true".
PARAMCHANGE : Instead of bypassing, changes FX parameter between val1 (low latency) and val2 (original). Use bufIn string format 'fx_name;param_index;val1;val2'.
KEEPPDC : Maintains PDC. Enable with any non-empty string. Disable (default) with empty string.
SAFE : Call with "clear" to clear all safed FX plugins.

int MCULive_GetButtonValue(int device, int button)
int MCULive_GetButtonValue(int device, int button) (requires REAPER 6.24 or later)
int extension_api("MCULive_GetButtonValue", int device, int button) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_GetButtonValue(integer device, integer button)
Int MCULive_GetButtonValue(Int device, Int button)

Get current button state.

int MCULive_GetDevice(int device, int type)
int MCULive_GetDevice(int device, int type) (requires REAPER 6.24 or later)
int extension_api("MCULive_GetDevice", int device, int type) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_GetDevice(integer device, integer type)
Int MCULive_GetDevice(Int device, Int type)

Get MIDI input or output dev ID. type 0 is input dev, type 1 is output dev. device < 0 returns number of MCULive devices.

double MCULive_GetEncoderValue(int device, int encIdx, int param)
double MCULive_GetEncoderValue(int device, int encIdx, int param) (requires REAPER 6.24 or later)
double extension_api("MCULive_GetEncoderValue", int device, int encIdx, int param) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.MCULive_GetEncoderValue(integer device, integer encIdx, integer param)
Float MCULive_GetEncoderValue(Int device, Int encIdx, Int param)

Returns zero-indexed encoder parameter value. 0 = lastpos, 1 = lasttouch

double MCULive_GetFaderValue(int device, int faderIdx, int param)
double MCULive_GetFaderValue(int device, int faderIdx, int param) (requires REAPER 6.24 or later)
double extension_api("MCULive_GetFaderValue", int device, int faderIdx, int param) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.MCULive_GetFaderValue(integer device, integer faderIdx, integer param)
Float MCULive_GetFaderValue(Int device, Int faderIdx, Int param)

Returns zero-indexed fader parameter value. 0 = lastpos, 1 = lasttouch, 2 = lastmove (any fader)

int MCULive_GetMIDIMessage(int device, int msgIdx, int* statusOut, int* data1Out, int* data2Out, int* frame_offsetOut, char* msgOutOptional, int msgOutOptional_sz)
int MCULive_GetMIDIMessage(int device, int msgIdx, int &status, int &data1, int &data2, int &frame_offset, optional #msg) (requires REAPER 6.24 or later)
int extension_api("MCULive_GetMIDIMessage", int device, int msgIdx, int &status, int &data1, int &data2, int &frame_offset, optional #msg) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, integer status, integer data1, integer data2, integer frame_offset, optional string msg = reaper.MCULive_GetMIDIMessage(integer device, integer msgIdx)
(Int retval, Int device, Int msgIdx, Int statusOut, Int data1Out, Int data2Out, Int frame_offsetOut, String msgOutOptional, Int msgOutOptional_sz) = MCULive_GetMIDIMessage(device, msgIdx, statusOut, data1Out, data2Out, frame_offsetOut, msgOutOptional, msgOutOptional_sz)

Gets MIDI message from input buffer/queue. Gets (pops/pulls) indexed message (status, data1, data2 and frame_offset) from queue and retval is total size/length left in queue. E.g. continuously read all indiviual messages with deferred script. Frame offset resolution is 1/1024000 seconds, not audio samples. Long messages are returned as optional strings of byte characters. msgIdx -1 returns size (length) of buffer. Read also non-MCU devices by creating MCULive device with their input.

int MCULive_Map(int device, int button, int command_id, bool isRemap)
int MCULive_Map(int device, int button, int command_id, bool isRemap) (requires REAPER 6.24 or later)
int extension_api("MCULive_Map", int device, int button, int command_id, bool isRemap) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_Map(integer device, integer button, integer command_id, boolean isRemap)
Int MCULive_Map(Int device, Int button, Int command_id, Boolean isRemap)

Maps MCU Live device# button# to REAPER command ID. E.g. reaper.MCULive_Map(0,0x5b, 40340) maps MCU Rewind to "Track: Unsolo all tracks". Or remap button to another button if your MCU button layout doesnt play nicely with default MCULive mappings. By default range 0x00 .. 0x2d is in use. Button numbers are second column (prefixed with 0x) e.g. '90 5e' 0x5e for 'transport : play', roughly.

mcu documentation:
mcu=>pc:
the mcu seems to send, when it boots (or is reset) f0 00 00 66 14 01 58 59 5a 57 18 61 05 57 18 61 05 f7
ex vv vv : volume fader move, x=0..7, 8=master, vv vv is int14
b0 1x vv : pan fader move, x=0..7, vv has 40 set if negative, low bits 0-31 are move amount
b0 3c vv : jog wheel move, 01 or 41
to the extent the buttons below have leds, you can set them by sending these messages, with 7f for on, 1 for blink, 0 for off.
90 0x vv : rec arm push x=0..7 (vv:..)
90 0x vv : solo push x=8..f (vv:..)
90 1x vv : mute push x=0..7 (vv:..)
90 1x vv : selected push x=8..f (vv:..)
90 2x vv : pan knob push, x=0..7 (vv:..)
90 28 vv : assignment track
90 29 vv : assignment send
90 2a vv : assignment pan/surround
90 2b vv : assignment plug-in
90 2c vv : assignment eq
90 2d vv : assignment instrument
90 2e vv : bank down button (vv: 00=release, 7f=push)
90 2f vv : channel down button (vv: ..)
90 30 vv : bank up button (vv:..)
90 31 vv : channel up button (vv:..)
90 32 vv : flip button
90 33 vv : global view button
90 34 vv : name/value display button
90 35 vv : smpte/beats mode switch (vv:..)
90 36 vv : f1
90 37 vv : f2
90 38 vv : f3
90 39 vv : f4
90 3a vv : f5
90 3b vv : f6
90 3c vv : f7
90 3d vv : f8
90 3e vv : global view : midi tracks
90 3f vv : global view : inputs
90 40 vv : global view : audio tracks
90 41 vv : global view : audio instrument
90 42 vv : global view : aux
90 43 vv : global view : busses
90 44 vv : global view : outputs
90 45 vv : global view : user
90 46 vv : shift modifier (vv:..)
90 47 vv : option modifier
90 48 vv : control modifier
90 49 vv : alt modifier
90 4a vv : automation read/off
90 4b vv : automation write
90 4c vv : automation trim
90 4d vv : automation touch
90 4e vv : automation latch
90 4f vv : automation group
90 50 vv : utilities save
90 51 vv : utilities undo
90 52 vv : utilities cancel
90 53 vv : utilities enter
90 54 vv : marker
90 55 vv : nudge
90 56 vv : cycle
90 57 vv : drop
90 58 vv : replace
90 59 vv : click
90 5a vv : solo
90 5b vv : transport rewind (vv:..)
90 5c vv : transport ffwd (vv:..)
90 5d vv : transport pause (vv:..)
90 5e vv : transport play (vv:..)
90 5f vv : transport record (vv:..)
90 60 vv : up arrow button (vv:..)
90 61 vv : down arrow button 1 (vv:..)
90 62 vv : left arrow button 1 (vv:..)
90 63 vv : right arrow button 1 (vv:..)
90 64 vv : zoom button (vv:..)
90 65 vv : scrub button (vv:..)
90 6x vv : fader touch x=8..f
90 70 vv : master fader touch
pc=>mcu:
f0 00 00 66 14 12 xx <data> f7 : update lcd. xx=offset (0-112), string. display is 55 chars wide, second line begins at 56, though.
f0 00 00 66 14 08 00 f7 : reset mcu
f0 00 00 66 14 20 0x 03 f7 : put track in vu meter mode, x=track
90 73 vv : rude solo light (vv: 7f=on, 00=off, 01=blink)
b0 3x vv : pan display, x=0..7, vv=1..17 (hex) or so
b0 4x vv : right to left of leds. if 0x40 set in vv, dot below char is set (x=0..11)
d0 yx : update vu meter, y=track, x=0..d=volume, e=clip on, f=clip off
ex vv vv : set volume fader, x=track index, 8=master

int MCULive_Reset(int device)
int MCULive_Reset(int device) (requires REAPER 6.24 or later)
int extension_api("MCULive_Reset", int device) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_Reset(integer device)
Int MCULive_Reset(Int device)

Reset device. device < 0 resets all and returns number of devices.

int MCULive_SendMIDIMessage(int device, int status, int data1, int data2, const char* msgInOptional, int msgInOptional_sz)
int MCULive_SendMIDIMessage(int device, int status, int data1, int data2, optional "msgIn") (requires REAPER 6.24 or later)
int extension_api("MCULive_SendMIDIMessage", int device, int status, int data1, int data2, optional "msgIn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_SendMIDIMessage(integer device, integer status, integer data1, integer data2, optional string msgIn)
Int MCULive_SendMIDIMessage(Int device, Int status, Int data1, Int data2, String msgInOptional, Int msgInOptional_sz)

Sends MIDI message to device. If string is provided, individual bytes are not sent. Returns number of sent bytes.

int MCULive_SetButtonPassthrough(int device, int button, bool isSet)
int MCULive_SetButtonPassthrough(int device, int button, bool isSet) (requires REAPER 6.24 or later)
int extension_api("MCULive_SetButtonPassthrough", int device, int button, bool isSet) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_SetButtonPassthrough(integer device, integer button, boolean isSet)
Int MCULive_SetButtonPassthrough(Int device, Int button, Boolean isSet)

Set button as MIDI passthrough.

int MCULive_SetButtonPressOnly(int device, int button, bool isSet)
int MCULive_SetButtonPressOnly(int device, int button, bool isSet) (requires REAPER 6.24 or later)
int extension_api("MCULive_SetButtonPressOnly", int device, int button, bool isSet) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_SetButtonPressOnly(integer device, integer button, boolean isSet)
Int MCULive_SetButtonPressOnly(Int device, Int button, Boolean isSet)

Buttons function as press only by default. Set false for press and release function.

int MCULive_SetButtonValue(int device, int button, int value)
int MCULive_SetButtonValue(int device, int button, int value) (requires REAPER 6.24 or later)
int extension_api("MCULive_SetButtonValue", int device, int button, int value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_SetButtonValue(integer device, integer button, integer value)
Int MCULive_SetButtonValue(Int device, Int button, Int value)

Set button led/mode/state. Value 0 = off,1 = blink, 0x7f = on, usually.

void MCULive_SetDefault(int device, bool isSet)
MCULive_SetDefault(int device, bool isSet) (requires REAPER 6.24 or later)
extension_api("MCULive_SetDefault", int device, bool isSet) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MCULive_SetDefault(integer device, boolean isSet)
MCULive_SetDefault(Int device, Boolean isSet)

Enables/disables default out-of-the-box operation.

void MCULive_SetDisplay(int device, int pos, const char* message, int pad)
MCULive_SetDisplay(int device, int pos, "message", int pad) (requires REAPER 6.24 or later)
extension_api("MCULive_SetDisplay", int device, int pos, "message", int pad) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MCULive_SetDisplay(integer device, integer pos, string message, integer pad)
MCULive_SetDisplay(Int device, Int pos, String message, Int pad)

Write to display. 112 characters, 56 per row.

int MCULive_SetEncoderValue(int device, int encIdx, double val, int type)
int MCULive_SetEncoderValue(int device, int encIdx, val, int type) (requires REAPER 6.24 or later)
int extension_api("MCULive_SetEncoderValue", int device, int encIdx, val, int type) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_SetEncoderValue(integer device, integer encIdx, number val, integer type)
Int MCULive_SetEncoderValue(Int device, Int encIdx, Float val, Int type)

Set encoder to value 0 ... 1.0. Type 0 = linear, 1 = track volume, 2 = pan. Returns scaled value.

int MCULive_SetFaderValue(int device, int faderIdx, double val, int type)
int MCULive_SetFaderValue(int device, int faderIdx, val, int type) (requires REAPER 6.24 or later)
int extension_api("MCULive_SetFaderValue", int device, int faderIdx, val, int type) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_SetFaderValue(integer device, integer faderIdx, number val, integer type)
Int MCULive_SetFaderValue(Int device, Int faderIdx, Float val, Int type)

Set fader to value 0 ... 1.0. Type 0 = linear, 1 = track volume, 2 = pan. Returns scaled value.

int MCULive_SetMeterValue(int device, int meterIdx, double val, int type)
int MCULive_SetMeterValue(int device, int meterIdx, val, int type) (requires REAPER 6.24 or later)
int extension_api("MCULive_SetMeterValue", int device, int meterIdx, val, int type) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MCULive_SetMeterValue(integer device, integer meterIdx, number val, integer type)
Int MCULive_SetMeterValue(Int device, Int meterIdx, Float val, Int type)

Set meter value 0 ... 1.0. Type 0 = linear, 1 = track volume (with decay).

void MCULive_SetOption(int option, int value)
MCULive_SetOption(int option, int value) (requires REAPER 6.24 or later)
extension_api("MCULive_SetOption", int option, int value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MCULive_SetOption(integer option, integer value)
MCULive_SetOption(Int option, Int value)

1 : surface split point device index
2 : 'mode-is-global' bitmask/flags, first 6 bits

int MRP_CalculateEnvelopeHash(TrackEnvelope* env)
int MRP_CalculateEnvelopeHash(TrackEnvelope env) (requires REAPER 6.24 or later)
int extension_api("MRP_CalculateEnvelopeHash", TrackEnvelope env) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MRP_CalculateEnvelopeHash(TrackEnvelope env)
Int MRP_CalculateEnvelopeHash(TrackEnvelope env)

This function isn't really correct... it calculates a 64 bit hash but returns it as a 32 bit int. Should reimplement this. Or rather, even more confusingly : The hash will be 32 bit when building for 32 bit architecture and 64 bit when building for 64 bit architecture! It comes down to how size_t is of different size between the 32 and 64 bit architectures.

int MRP_CastDoubleToInt(double n1, double n2)
int MRP_CastDoubleToInt(n1, n2) (requires REAPER 6.24 or later)
int extension_api("MRP_CastDoubleToInt", n1, n2) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MRP_CastDoubleToInt(number n1, number n2)
Int MRP_CastDoubleToInt(Float n1, Float n2)

add two numbers

MRP_Array* MRP_CreateArray(int size)
MRP_Array MRP_CreateArray(int size) (requires REAPER 6.24 or later)
MRP_Array extension_api("MRP_CreateArray", int size) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MRP_Array reaper.MRP_CreateArray(integer size)
MRP_Array MRP_CreateArray(Int size)

Create an array of 64 bit floating point numbers. Note that these will leak memory if they are not later destroyed with MRP_DestroyArray!

MRP_Window* MRP_CreateWindow(const char* title)
MRP_Window MRP_CreateWindow("title") (requires REAPER 6.24 or later)
MRP_Window extension_api("MRP_CreateWindow", "title") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MRP_Window reaper.MRP_CreateWindow(string title)
MRP_Window MRP_CreateWindow(String title)

Create window

void MRP_DestroyArray(MRP_Array* array)
MRP_DestroyArray(MRP_Array array) (requires REAPER 6.24 or later)
extension_api("MRP_DestroyArray", MRP_Array array) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_DestroyArray(MRP_Array array)
MRP_DestroyArray(MRP_Array array)

Destroy a previously created MRP_Array

void MRP_DestroyWindow(MRP_Window* window)
MRP_DestroyWindow(MRP_Window window) (requires REAPER 6.24 or later)
extension_api("MRP_DestroyWindow", MRP_Window window) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_DestroyWindow(MRP_Window window)
MRP_DestroyWindow(MRP_Window window)

Destroy window

void MRP_DoNothing()
MRP_DoNothing() (requires REAPER 6.24 or later)
extension_api("MRP_DoNothing") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_DoNothing()
MRP_DoNothing()

do nothing, return null

double MRP_DoublePointer(double n1, double n2)
double MRP_DoublePointer(n1, n2) (requires REAPER 6.24 or later)
double extension_api("MRP_DoublePointer", n1, n2) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.MRP_DoublePointer(number n1, number n2)
Float MRP_DoublePointer(Float n1, Float n2)

add two numbers

int MRP_DoublePointerAsInt(double n1, double n2)
int MRP_DoublePointerAsInt(n1, n2) (requires REAPER 6.24 or later)
int extension_api("MRP_DoublePointerAsInt", n1, n2) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MRP_DoublePointerAsInt(number n1, number n2)
Int MRP_DoublePointerAsInt(Float n1, Float n2)

add two numbers

void MRP_GenerateSine(MRP_Array* array, double samplerate, double frequency)
MRP_GenerateSine(MRP_Array array, samplerate, frequency) (requires REAPER 6.24 or later)
extension_api("MRP_GenerateSine", MRP_Array array, samplerate, frequency) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_GenerateSine(MRP_Array array, number samplerate, number frequency)
MRP_GenerateSine(MRP_Array array, Float samplerate, Float frequency)

Generate a sine wave into a MRP_Array

double MRP_GetArrayValue(MRP_Array* array, int index)
double MRP_GetArrayValue(MRP_Array array, int index) (requires REAPER 6.24 or later)
double extension_api("MRP_GetArrayValue", MRP_Array array, int index) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.MRP_GetArrayValue(MRP_Array array, integer index)
Float MRP_GetArrayValue(MRP_Array array, Int index)

Get MRP_Array element value. No safety checks done for array or index validity, so use at your own peril!

double MRP_GetControlFloatNumber(MRP_Window* window, const char* controlname, int which)
double MRP_GetControlFloatNumber(MRP_Window window, "controlname", int which) (requires REAPER 6.24 or later)
double extension_api("MRP_GetControlFloatNumber", MRP_Window window, "controlname", int which) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.MRP_GetControlFloatNumber(MRP_Window window, string controlname, integer which)
Float MRP_GetControlFloatNumber(MRP_Window window, String controlname, Int which)

Get a floating point number associated with control. Meaning of 'which' depends on the control targeted.

int MRP_GetControlIntNumber(MRP_Window* window, const char* controlname, int which)
int MRP_GetControlIntNumber(MRP_Window window, "controlname", int which) (requires REAPER 6.24 or later)
int extension_api("MRP_GetControlIntNumber", MRP_Window window, "controlname", int which) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MRP_GetControlIntNumber(MRP_Window window, string controlname, integer which)
Int MRP_GetControlIntNumber(MRP_Window window, String controlname, Int which)

Get an integer point number associated with control. Meaning of 'which' depends on the control targeted.

bool MRP_GetWindowDirty(MRP_Window* window, int whichdirty)
bool MRP_GetWindowDirty(MRP_Window window, int whichdirty) (requires REAPER 6.24 or later)
bool extension_api("MRP_GetWindowDirty", MRP_Window window, int whichdirty) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.MRP_GetWindowDirty(MRP_Window window, integer whichdirty)
Boolean MRP_GetWindowDirty(MRP_Window window, Int whichdirty)

Get window dirty state (ie, if something was changed in the window). which : 0 window size

int MRP_GetWindowPosSizeValue(MRP_Window* window, int which)
int MRP_GetWindowPosSizeValue(MRP_Window window, int which) (requires REAPER 6.24 or later)
int extension_api("MRP_GetWindowPosSizeValue", MRP_Window window, int which) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MRP_GetWindowPosSizeValue(MRP_Window window, integer which)
Int MRP_GetWindowPosSizeValue(MRP_Window window, Int which)

Get window geometry values. which : 0 x, 1 y, 2 w, 3 h

int MRP_IntPointer(int n1, int n2)
int MRP_IntPointer(int n1, int n2) (requires REAPER 6.24 or later)
int extension_api("MRP_IntPointer", int n1, int n2) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.MRP_IntPointer(integer n1, integer n2)
Int MRP_IntPointer(Int n1, Int n2)

add two numbers

void MRP_MultiplyArrays(MRP_Array* array1, MRP_Array* array2, MRP_Array* array3)
MRP_MultiplyArrays(MRP_Array array1, MRP_Array array2, MRP_Array array3) (requires REAPER 6.24 or later)
extension_api("MRP_MultiplyArrays", MRP_Array array1, MRP_Array array2, MRP_Array array3) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_MultiplyArrays(MRP_Array array1, MRP_Array array2, MRP_Array array3)
MRP_MultiplyArrays(MRP_Array array1, MRP_Array array2, MRP_Array array3)

Multiply 2 MRP_Arrays of same length. Result is written to 3rd array.

void MRP_MultiplyArraysMT(MRP_Array* array1, MRP_Array* array2, MRP_Array* array3)
MRP_MultiplyArraysMT(MRP_Array array1, MRP_Array array2, MRP_Array array3) (requires REAPER 6.24 or later)
extension_api("MRP_MultiplyArraysMT", MRP_Array array1, MRP_Array array2, MRP_Array array3) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_MultiplyArraysMT(MRP_Array array1, MRP_Array array2, MRP_Array array3)
MRP_MultiplyArraysMT(MRP_Array array1, MRP_Array array2, MRP_Array array3)

Multiply 2 MRP_Arrays of same length. Result is written to 3rd array. Uses multiple threads.

MediaItem* MRP_ReturnMediaItem()
MediaItem MRP_ReturnMediaItem() (requires REAPER 6.24 or later)
MediaItem extension_api("MRP_ReturnMediaItem") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaItem reaper.MRP_ReturnMediaItem()
MediaItem MRP_ReturnMediaItem()

return media item

void MRP_SendCommandString(MRP_Window* window, const char* controlname, const char* commandtext)
MRP_SendCommandString(MRP_Window window, "controlname", "commandtext") (requires REAPER 6.24 or later)
extension_api("MRP_SendCommandString", MRP_Window window, "controlname", "commandtext") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_SendCommandString(MRP_Window window, string controlname, string commandtext)
MRP_SendCommandString(MRP_Window window, String controlname, String commandtext)

Send a command message to control. Currently only the envelope control understands some messages.

void MRP_SetArrayValue(MRP_Array* array, int index, double value)
MRP_SetArrayValue(MRP_Array array, int index, value) (requires REAPER 6.24 or later)
extension_api("MRP_SetArrayValue", MRP_Array array, int index, value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_SetArrayValue(MRP_Array array, integer index, number value)
MRP_SetArrayValue(MRP_Array array, Int index, Float value)

Set MRP_Array element value. No safety checks done for array or index validity, so use at your own peril!

void MRP_SetControlBounds(MRP_Window* window, const char* name, double x, double y, double w, double h)
MRP_SetControlBounds(MRP_Window window, "name", x, y, w, h) (requires REAPER 6.24 or later)
extension_api("MRP_SetControlBounds", MRP_Window window, "name", x, y, w, h) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_SetControlBounds(MRP_Window window, string name, number x, number y, number w, number h)
MRP_SetControlBounds(MRP_Window window, String name, Float x, Float y, Float w, Float h)

Set MRP control position and size

void MRP_SetControlFloatNumber(MRP_Window* window, const char* controlname, int which, double value)
MRP_SetControlFloatNumber(MRP_Window window, "controlname", int which, value) (requires REAPER 6.24 or later)
extension_api("MRP_SetControlFloatNumber", MRP_Window window, "controlname", int which, value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_SetControlFloatNumber(MRP_Window window, string controlname, integer which, number value)
MRP_SetControlFloatNumber(MRP_Window window, String controlname, Int which, Float value)

Set a floating point number associated with control. Meaning of 'which' depends on the control targeted.

void MRP_SetControlIntNumber(MRP_Window* window, const char* controlname, int which, int value)
MRP_SetControlIntNumber(MRP_Window window, "controlname", int which, int value) (requires REAPER 6.24 or later)
extension_api("MRP_SetControlIntNumber", MRP_Window window, "controlname", int which, int value) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_SetControlIntNumber(MRP_Window window, string controlname, integer which, integer value)
MRP_SetControlIntNumber(MRP_Window window, String controlname, Int which, Int value)

Set an integer point number associated with control. Meaning of 'which' depends on the control targeted.

void MRP_SetControlString(MRP_Window* window, const char* controlname, int which, const char* text)
MRP_SetControlString(MRP_Window window, "controlname", int which, "text") (requires REAPER 6.24 or later)
extension_api("MRP_SetControlString", MRP_Window window, "controlname", int which, "text") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_SetControlString(MRP_Window window, string controlname, integer which, string text)
MRP_SetControlString(MRP_Window window, String controlname, Int which, String text)

Set a text property associated with control. Meaning of 'which' depends on the control targeted.

void MRP_SetWindowDirty(MRP_Window* window, int which, bool state)
MRP_SetWindowDirty(MRP_Window window, int which, bool state) (requires REAPER 6.24 or later)
extension_api("MRP_SetWindowDirty", MRP_Window window, int which, bool state) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_SetWindowDirty(MRP_Window window, integer which, boolean state)
MRP_SetWindowDirty(MRP_Window window, Int which, Boolean state)

Set window dirty state (ie, if something was changed in the controls)

void MRP_WindowAddControl(MRP_Window* window, const char* controltypename, const char* objectname)
MRP_WindowAddControl(MRP_Window window, "controltypename", "objectname") (requires REAPER 6.24 or later)
extension_api("MRP_WindowAddControl", MRP_Window window, "controltypename", "objectname") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_WindowAddControl(MRP_Window window, string controltypename, string objectname)
MRP_WindowAddControl(MRP_Window window, String controltypename, String objectname)

Add a control to window. Controltypename is the type of control to create. Objectname must be a unique id

void MRP_WindowClearDirtyControls(MRP_Window* window)
MRP_WindowClearDirtyControls(MRP_Window window) (requires REAPER 6.24 or later)
extension_api("MRP_WindowClearDirtyControls", MRP_Window window) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_WindowClearDirtyControls(MRP_Window window)
MRP_WindowClearDirtyControls(MRP_Window window)

Clears the dirty states of the controls in a window.

bool MRP_WindowIsClosed(MRP_Window* window)
bool MRP_WindowIsClosed(MRP_Window window) (requires REAPER 6.24 or later)
bool extension_api("MRP_WindowIsClosed", MRP_Window window) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.MRP_WindowIsClosed(MRP_Window window)
Boolean MRP_WindowIsClosed(MRP_Window window)

Returns if the window has been closed and the ReaScript defer loop should likely be exited

bool MRP_WindowIsDirtyControl(MRP_Window* window, const char* controlname)
bool MRP_WindowIsDirtyControl(MRP_Window window, "controlname") (requires REAPER 6.24 or later)
bool extension_api("MRP_WindowIsDirtyControl", MRP_Window window, "controlname") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.MRP_WindowIsDirtyControl(MRP_Window window, string controlname)
Boolean MRP_WindowIsDirtyControl(MRP_Window window, String controlname)

Returns true if control was manipulated

void MRP_WindowSetTitle(MRP_Window* window, const char* title)
MRP_WindowSetTitle(MRP_Window window, "title") (requires REAPER 6.24 or later)
extension_api("MRP_WindowSetTitle", MRP_Window window, "title") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_WindowSetTitle(MRP_Window window, string title)
MRP_WindowSetTitle(MRP_Window window, String title)

Set window title

void MRP_WriteArrayToFile(MRP_Array* array, const char* filename, double samplerate)
MRP_WriteArrayToFile(MRP_Array array, "filename", samplerate) (requires REAPER 6.24 or later)
extension_api("MRP_WriteArrayToFile", MRP_Array array, "filename", samplerate) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.MRP_WriteArrayToFile(MRP_Array array, string filename, number samplerate)
MRP_WriteArrayToFile(MRP_Array array, String filename, Float samplerate)

Write MRP_Array to disk as a 32 bit floating point mono wav file

bool NF_AnalyzeMediaItemPeakAndRMS(MediaItem* item, double windowSize, void* reaper.array_peaks, void* reaper.array_peakpositions, void* reaper.array_RMSs, void* reaper.array_RMSpositions)
bool NF_AnalyzeMediaItemPeakAndRMS(MediaItem item, windowSize, void* reaper.array_peaks, void* reaper.array_peakpositions, void* reaper.array_RMSs, void* reaper.array_RMSpositions) (requires REAPER 6.24 or later)
bool extension_api("NF_AnalyzeMediaItemPeakAndRMS", MediaItem item, windowSize, void* reaper.array_peaks, void* reaper.array_peakpositions, void* reaper.array_RMSs, void* reaper.array_RMSpositions) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_AnalyzeMediaItemPeakAndRMS(MediaItem item, number windowSize, identifier reaper.array_peaks, identifier reaper.array_peakpositions, identifier reaper.array_RMSs, identifier reaper.array_RMSpositions)
Boolean NF_AnalyzeMediaItemPeakAndRMS(MediaItem item, Float windowSize, void reaper.array_peaks, void reaper.array_peakpositions, void reaper.array_RMSs, void reaper.array_RMSpositions)

This function combines all other NF_Peak/RMS functions in a single one and additionally returns peak RMS positions. Lua example code here. Note: It's recommended to use this function with ReaScript/Lua as it provides reaper.array objects. If using this function with other scripting languages, you must provide arrays in the reaper.array format.

bool NF_AnalyzeTakeLoudness(MediaItem_Take* take, bool analyzeTruePeak, double* lufsIntegratedOut, double* rangeOut, double* truePeakOut, double* truePeakPosOut, double* shortTermMaxOut, double* momentaryMaxOut)
bool NF_AnalyzeTakeLoudness(MediaItem_Take take, bool analyzeTruePeak, &lufsIntegrated, &range, & truePeak, &truePeakPos, &shortTermMax, &momentaryMax) (requires REAPER 6.24 or later)
bool extension_api("NF_AnalyzeTakeLoudness", MediaItem_Take take, bool analyzeTruePeak, &lufsIntegrated, &range, & truePeak, &truePeakPos, &shortTermMax, &momentaryMax) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number lufsIntegrated, number range, number truePeak, number truePeakPos, number shortTermMax, number momentaryMax = reaper.NF_AnalyzeTakeLoudness(MediaItem_Take take, boolean analyzeTruePeak)
(Boolean retval, MediaItem_Take take, Boolean analyzeTruePeak, Float lufsIntegratedOut, Float rangeOut, Float truePeakOut, Float truePeakPosOut, Float shortTermMaxOut, Float momentaryMaxOut) = NF_AnalyzeTakeLoudness(take, analyzeTruePeak, lufsIntegratedOut, rangeOut, truePeakOut, truePeakPosOut, shortTermMaxOut, momentaryMaxOut)

Full loudness analysis. retval: returns true on successful analysis, false on MIDI take or when analysis failed for some reason. analyzeTruePeak=true: Also do true peak analysis. Returns true peak value in dBTP and true peak position (relative to item position). Considerably slower than without true peak analysis (since it uses oversampling). Note: Short term uses a time window of 3 sec. for calculation. So for items shorter than this shortTermMaxOut can't be calculated correctly. Momentary uses a time window of 0.4 sec.

bool NF_AnalyzeTakeLoudness2(MediaItem_Take* take, bool analyzeTruePeak, double* lufsIntegratedOut, double* rangeOut, double* truePeakOut, double* truePeakPosOut, double* shortTermMaxOut, double* momentaryMaxOut, double* shortTermMaxPosOut, double* momentaryMaxPosOut)
bool NF_AnalyzeTakeLoudness2(MediaItem_Take take, bool analyzeTruePeak, &lufsIntegrated, &range, & truePeak, &truePeakPos, &shortTermMax, &momentaryMax, &shortTermMaxPos, &momentaryMaxPos) (requires REAPER 6.24 or later)
bool extension_api("NF_AnalyzeTakeLoudness2", MediaItem_Take take, bool analyzeTruePeak, &lufsIntegrated, &range, & truePeak, &truePeakPos, &shortTermMax, &momentaryMax, &shortTermMaxPos, &momentaryMaxPos) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number lufsIntegrated, number range, number truePeak, number truePeakPos, number shortTermMax, number momentaryMax, number shortTermMaxPos, number momentaryMaxPos = reaper.NF_AnalyzeTakeLoudness2(MediaItem_Take take, boolean analyzeTruePeak)
(Boolean retval, MediaItem_Take take, Boolean analyzeTruePeak, Float lufsIntegratedOut, Float rangeOut, Float truePeakOut, Float truePeakPosOut, Float shortTermMaxOut, Float momentaryMaxOut, Float shortTermMaxPosOut, Float momentaryMaxPosOut) = NF_AnalyzeTakeLoudness2(take, analyzeTruePeak, lufsIntegratedOut, rangeOut, truePeakOut, truePeakPosOut, shortTermMaxOut, momentaryMaxOut, shortTermMaxPosOut, momentaryMaxPosOut)

Same as NF_AnalyzeTakeLoudness but additionally returns shortTermMaxPos and momentaryMaxPos (in absolute project time). Note: shortTermMaxPos and momentaryMaxPos indicate the beginning of time intervalls, (3 sec. and 0.4 sec. resp.).

bool NF_AnalyzeTakeLoudness_IntegratedOnly(MediaItem_Take* take, double* lufsIntegratedOut)
bool NF_AnalyzeTakeLoudness_IntegratedOnly(MediaItem_Take take, &lufsIntegrated) (requires REAPER 6.24 or later)
bool extension_api("NF_AnalyzeTakeLoudness_IntegratedOnly", MediaItem_Take take, &lufsIntegrated) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, number lufsIntegrated = reaper.NF_AnalyzeTakeLoudness_IntegratedOnly(MediaItem_Take take)
(Boolean retval, MediaItem_Take take, Float lufsIntegratedOut) = NF_AnalyzeTakeLoudness_IntegratedOnly(take, lufsIntegratedOut)

Does LUFS integrated analysis only. Faster than full loudness analysis (NF_AnalyzeTakeLoudness) . Use this if only LUFS integrated is required. Take vol. env. is taken into account. See: Signal flow

bool NF_Base64_Decode(const char* base64Str, char* decodedStrOutNeedBig, int decodedStrOutNeedBig_sz)
bool NF_Base64_Decode("base64Str", #decodedStr) (requires REAPER 6.24 or later)
bool extension_api("NF_Base64_Decode", "base64Str", #decodedStr) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string decodedStr = reaper.NF_Base64_Decode(string base64Str)
(Boolean retval, String base64Str, String decodedStrOutNeedBig, Int decodedStrOutNeedBig_sz) = NF_Base64_Decode(base64Str, decodedStrOutNeedBig, decodedStrOutNeedBig_sz)

Returns true on success.

void NF_Base64_Encode(const char* str, int str_sz, bool usePadding, char* encodedStrOutNeedBig, int encodedStrOutNeedBig_sz)
NF_Base64_Encode("str", bool usePadding, #encodedStr) (requires REAPER 6.24 or later)
extension_api("NF_Base64_Encode", "str", bool usePadding, #encodedStr) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string encodedStr = reaper.NF_Base64_Encode(string str, boolean usePadding)
(String str, Int str_sz, Boolean usePadding, String encodedStrOutNeedBig, Int encodedStrOutNeedBig_sz) = NF_Base64_Encode(str, str_sz, usePadding, encodedStrOutNeedBig, encodedStrOutNeedBig_sz)

Input string may contain null bytes in REAPER 6.44 or newer. Note: Doesn't allow padding in the middle (e.g. concatenated encoded strings), doesn't allow newlines.

bool NF_ClearGlobalStartupAction()
bool NF_ClearGlobalStartupAction() (requires REAPER 6.24 or later)
bool extension_api("NF_ClearGlobalStartupAction") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_ClearGlobalStartupAction()
Boolean NF_ClearGlobalStartupAction()

Returns true if global startup action was cleared successfully.

bool NF_ClearProjectStartupAction()
bool NF_ClearProjectStartupAction() (requires REAPER 6.24 or later)
bool extension_api("NF_ClearProjectStartupAction") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_ClearProjectStartupAction()
Boolean NF_ClearProjectStartupAction()

Returns true if project startup action was cleared successfully.

bool NF_ClearProjectTrackSelectionAction()
bool NF_ClearProjectTrackSelectionAction() (requires REAPER 6.24 or later)
bool extension_api("NF_ClearProjectTrackSelectionAction") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_ClearProjectTrackSelectionAction()
Boolean NF_ClearProjectTrackSelectionAction()

Returns true if project track selection action was cleared successfully.

bool NF_DeleteTakeFromItem(MediaItem* item, int takeIdx)
bool NF_DeleteTakeFromItem(MediaItem item, int takeIdx) (requires REAPER 6.24 or later)
bool extension_api("NF_DeleteTakeFromItem", MediaItem item, int takeIdx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_DeleteTakeFromItem(MediaItem item, integer takeIdx)
Boolean NF_DeleteTakeFromItem(MediaItem item, Int takeIdx)

Deletes a take from an item. takeIdx is zero-based. Returns true on success.

bool NF_GetGlobalStartupAction(char* descOut, int descOut_sz, char* cmdIdOut, int cmdIdOut_sz)
bool NF_GetGlobalStartupAction(#desc, #cmdId) (requires REAPER 6.24 or later)
bool extension_api("NF_GetGlobalStartupAction", #desc, #cmdId) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string desc, string cmdId = reaper.NF_GetGlobalStartupAction()
(Boolean retval, String descOut, Int descOut_sz, String cmdIdOut, Int cmdIdOut_sz) = NF_GetGlobalStartupAction(descOut, descOut_sz, cmdIdOut, cmdIdOut_sz)

Gets action description and command ID number (for native actions) or named command IDs / identifier strings (for extension actions /ReaScripts) if global startup action is set, otherwise empty string. Returns false on failure.

double NF_GetMediaItemAverageRMS(MediaItem* item)
double NF_GetMediaItemAverageRMS(MediaItem item) (requires REAPER 6.24 or later)
double extension_api("NF_GetMediaItemAverageRMS", MediaItem item) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.NF_GetMediaItemAverageRMS(MediaItem item)
Float NF_GetMediaItemAverageRMS(MediaItem item)

Returns the average overall (non-windowed) dB RMS level of active channels of an audio item active take, post item gain, post take volume envelope, post-fade, pre fader, pre item FX.
Returns -150.0 if MIDI take or empty item.

double NF_GetMediaItemMaxPeak(MediaItem* item)
double NF_GetMediaItemMaxPeak(MediaItem item) (requires REAPER 6.24 or later)
double extension_api("NF_GetMediaItemMaxPeak", MediaItem item) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.NF_GetMediaItemMaxPeak(MediaItem item)
Float NF_GetMediaItemMaxPeak(MediaItem item)

Returns the greatest max. peak value in dBFS of all active channels of an audio item active take, post item gain, post take volume envelope, post-fade, pre fader, pre item FX.
Returns -150.0 if MIDI take or empty item.

double NF_GetMediaItemMaxPeakAndMaxPeakPos(MediaItem* item, double* maxPeakPosOut)
double NF_GetMediaItemMaxPeakAndMaxPeakPos(MediaItem item, &maxPeakPos) (requires REAPER 6.24 or later)
double extension_api("NF_GetMediaItemMaxPeakAndMaxPeakPos", MediaItem item, &maxPeakPos) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number retval, number maxPeakPos = reaper.NF_GetMediaItemMaxPeakAndMaxPeakPos(MediaItem item)
(Float retval, MediaItem item, Float maxPeakPosOut) = NF_GetMediaItemMaxPeakAndMaxPeakPos(item, maxPeakPosOut)

See NF_GetMediaItemMaxPeak, additionally returns maxPeakPos (relative to item position).

double NF_GetMediaItemPeakRMS_NonWindowed(MediaItem* item)
double NF_GetMediaItemPeakRMS_NonWindowed(MediaItem item) (requires REAPER 6.24 or later)
double extension_api("NF_GetMediaItemPeakRMS_NonWindowed", MediaItem item) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.NF_GetMediaItemPeakRMS_NonWindowed(MediaItem item)
Float NF_GetMediaItemPeakRMS_NonWindowed(MediaItem item)

Returns the greatest overall (non-windowed) dB RMS peak level of all active channels of an audio item active take, post item gain, post take volume envelope, post-fade, pre fader, pre item FX.
Returns -150.0 if MIDI take or empty item.

double NF_GetMediaItemPeakRMS_Windowed(MediaItem* item)
double NF_GetMediaItemPeakRMS_Windowed(MediaItem item) (requires REAPER 6.24 or later)
double extension_api("NF_GetMediaItemPeakRMS_Windowed", MediaItem item) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.NF_GetMediaItemPeakRMS_Windowed(MediaItem item)
Float NF_GetMediaItemPeakRMS_Windowed(MediaItem item)

Returns the average dB RMS peak level of all active channels of an audio item active take, post item gain, post take volume envelope, post-fade, pre fader, pre item FX.
Obeys 'Window size for peak RMS' setting in 'SWS: Set RMS analysis/normalize options' for calculation. Returns -150.0 if MIDI take or empty item.

bool NF_GetProjectStartupAction(char* descOut, int descOut_sz, char* cmdIdOut, int cmdIdOut_sz)
bool NF_GetProjectStartupAction(#desc, #cmdId) (requires REAPER 6.24 or later)
bool extension_api("NF_GetProjectStartupAction", #desc, #cmdId) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string desc, string cmdId = reaper.NF_GetProjectStartupAction()
(Boolean retval, String descOut, Int descOut_sz, String cmdIdOut, Int cmdIdOut_sz) = NF_GetProjectStartupAction(descOut, descOut_sz, cmdIdOut, cmdIdOut_sz)

Gets action description and command ID number (for native actions) or named command IDs / identifier strings (for extension actions /ReaScripts) if project startup action is set, otherwise empty string. Returns false on failure.

bool NF_GetProjectTrackSelectionAction(char* descOut, int descOut_sz, char* cmdIdOut, int cmdIdOut_sz)
bool NF_GetProjectTrackSelectionAction(#desc, #cmdId) (requires REAPER 6.24 or later)
bool extension_api("NF_GetProjectTrackSelectionAction", #desc, #cmdId) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string desc, string cmdId = reaper.NF_GetProjectTrackSelectionAction()
(Boolean retval, String descOut, Int descOut_sz, String cmdIdOut, Int cmdIdOut_sz) = NF_GetProjectTrackSelectionAction(descOut, descOut_sz, cmdIdOut, cmdIdOut_sz)

Gets action description and command ID number (for native actions) or named command IDs / identifier strings (for extension actions /ReaScripts) if project track selection action is set, otherwise empty string. Returns false on failure.

const char* NF_GetSWSMarkerRegionSub(int markerRegionIdx)
bool NF_GetSWSMarkerRegionSub(#retval, int markerRegionIdx) (requires REAPER 6.24 or later)
bool extension_api("NF_GetSWSMarkerRegionSub", #retval, int markerRegionIdx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string reaper.NF_GetSWSMarkerRegionSub(integer markerRegionIdx)
String NF_GetSWSMarkerRegionSub(Int markerRegionIdx)

Returns SWS/S&M marker/region subtitle. markerRegionIdx: Refers to index that can be passed to EnumProjectMarkers (not displayed marker/region index). Returns empty string if marker/region with specified index not found or marker/region subtitle not set. Lua code example here.

const char* NF_GetSWSTrackNotes(MediaTrack* track)
bool NF_GetSWSTrackNotes(#retval, MediaTrack track) (requires REAPER 6.24 or later)
bool extension_api("NF_GetSWSTrackNotes", #retval, MediaTrack track) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string reaper.NF_GetSWSTrackNotes(MediaTrack track)
String NF_GetSWSTrackNotes(MediaTrack track)
void NF_GetSWS_RMSoptions(double* targetOut, double* windowSizeOut)
NF_GetSWS_RMSoptions(&target, &windowSize) (requires REAPER 6.24 or later)
extension_api("NF_GetSWS_RMSoptions", &target, &windowSize) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number target, number windowSize = reaper.NF_GetSWS_RMSoptions()
(Float targetOut, Float windowSizeOut) = NF_GetSWS_RMSoptions(targetOut, windowSizeOut)

Get SWS analysis/normalize options. See NF_SetSWS_RMSoptions.

int NF_ReadAudioFileBitrate(const char* fn)
int NF_ReadAudioFileBitrate("fn") (requires REAPER 6.24 or later)
int extension_api("NF_ReadAudioFileBitrate", "fn") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.NF_ReadAudioFileBitrate(string fn)
Int NF_ReadAudioFileBitrate(String fn)

Returns the bitrate of an audio file in kb/s if available (0 otherwise). For supported filetypes see TagLib::AudioProperties::bitrate.

void NF_ScrollHorizontallyByPercentage(int amount)
NF_ScrollHorizontallyByPercentage(int amount) (requires REAPER 6.24 or later)
extension_api("NF_ScrollHorizontallyByPercentage", int amount) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.NF_ScrollHorizontallyByPercentage(integer amount)
NF_ScrollHorizontallyByPercentage(Int amount)

100 means scroll one page. Negative values scroll left.

bool NF_SetGlobalStartupAction(const char* str)
bool NF_SetGlobalStartupAction("str") (requires REAPER 6.24 or later)
bool extension_api("NF_SetGlobalStartupAction", "str") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_SetGlobalStartupAction(string str)
Boolean NF_SetGlobalStartupAction(String str)

Returns true if global startup action was set successfully (i.e. valid action ID). Note: For SWS / S&M actions and macros / scripts, you must use identifier strings (e.g. "_SWS_ABOUT", "_f506bc780a0ab34b8fdedb67ed5d3649"), not command IDs (e.g. "47145").
Tip: to copy such identifiers, right-click the action in the Actions window > Copy selected action cmdID / identifier string.
NOnly works for actions / scripts from Main action section.

bool NF_SetProjectStartupAction(const char* str)
bool NF_SetProjectStartupAction("str") (requires REAPER 6.24 or later)
bool extension_api("NF_SetProjectStartupAction", "str") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_SetProjectStartupAction(string str)
Boolean NF_SetProjectStartupAction(String str)

Returns true if project startup action was set successfully (i.e. valid action ID). Note: For SWS / S&M actions and macros / scripts, you must use identifier strings (e.g. "_SWS_ABOUT", "_f506bc780a0ab34b8fdedb67ed5d3649"), not command IDs (e.g. "47145").
Tip: to copy such identifiers, right-click the action in the Actions window > Copy selected action cmdID / identifier string.
Only works for actions / scripts from Main action section. Project must be saved after setting project startup action to be persistent.

bool NF_SetProjectTrackSelectionAction(const char* str)
bool NF_SetProjectTrackSelectionAction("str") (requires REAPER 6.24 or later)
bool extension_api("NF_SetProjectTrackSelectionAction", "str") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_SetProjectTrackSelectionAction(string str)
Boolean NF_SetProjectTrackSelectionAction(String str)

Returns true if project track selection action was set successfully (i.e. valid action ID). Note: For SWS / S&M actions and macros / scripts, you must use identifier strings (e.g. "_SWS_ABOUT", "_f506bc780a0ab34b8fdedb67ed5d3649"), not command IDs (e.g. "47145").
Tip: to copy such identifiers, right-click the action in the Actions window > Copy selected action cmdID / identifier string.
Only works for actions / scripts from Main action section. Project must be saved after setting project track selection action to be persistent.

bool NF_SetSWSMarkerRegionSub(const char* markerRegionSub, int markerRegionIdx)
bool NF_SetSWSMarkerRegionSub("markerRegionSub", int markerRegionIdx) (requires REAPER 6.24 or later)
bool extension_api("NF_SetSWSMarkerRegionSub", "markerRegionSub", int markerRegionIdx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_SetSWSMarkerRegionSub(string markerRegionSub, integer markerRegionIdx)
Boolean NF_SetSWSMarkerRegionSub(String markerRegionSub, Int markerRegionIdx)

Set SWS/S&M marker/region subtitle. markerRegionIdx: Refers to index that can be passed to EnumProjectMarkers (not displayed marker/region index). Returns true if subtitle is set successfully (i.e. marker/region with specified index is present in project). Lua code example here.

void NF_SetSWSTrackNotes(MediaTrack* track, const char* str)
NF_SetSWSTrackNotes(MediaTrack track, "str") (requires REAPER 6.24 or later)
extension_api("NF_SetSWSTrackNotes", MediaTrack track, "str") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.NF_SetSWSTrackNotes(MediaTrack track, string str)
NF_SetSWSTrackNotes(MediaTrack track, String str)
bool NF_SetSWS_RMSoptions(double targetLevel, double windowSize)
bool NF_SetSWS_RMSoptions(targetLevel, windowSize) (requires REAPER 6.24 or later)
bool extension_api("NF_SetSWS_RMSoptions", targetLevel, windowSize) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.NF_SetSWS_RMSoptions(number targetLevel, number windowSize)
Boolean NF_SetSWS_RMSoptions(Float targetLevel, Float windowSize)

Set SWS analysis/normalize options (same as running action 'SWS: Set RMS analysis/normalize options'). targetLevel: target RMS normalize level (dB), windowSize: window size for peak RMS (sec.)

bool NF_TakeFX_GetFXModuleName(MediaItem* item, int fx, char* nameOut, int nameOut_sz)
bool NF_TakeFX_GetFXModuleName(MediaItem item, int fx, #name) (requires REAPER 6.24 or later)
bool extension_api("NF_TakeFX_GetFXModuleName", MediaItem item, int fx, #name) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string name = reaper.NF_TakeFX_GetFXModuleName(MediaItem item, integer fx)
(Boolean retval, MediaItem item, Int fx, String nameOut, Int nameOut_sz) = NF_TakeFX_GetFXModuleName(item, fx, nameOut, nameOut_sz)

Deprecated, see TakeFX_GetNamedConfigParm/'fx_ident' (v6.37+). See BR_TrackFX_GetFXModuleName. fx: counted consecutively across all takes (zero-based).

void NF_UpdateSWSMarkerRegionSubWindow()
NF_UpdateSWSMarkerRegionSubWindow() (requires REAPER 6.24 or later)
extension_api("NF_UpdateSWSMarkerRegionSubWindow") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.NF_UpdateSWSMarkerRegionSubWindow()
NF_UpdateSWSMarkerRegionSubWindow()

Redraw the Notes window (call if you've changed a subtitle via NF_SetSWSMarkerRegionSub which is currently displayed in the Notes window and you want to appear the new subtitle immediately.)

int NF_Win32_GetSystemMetrics(int nIndex)
int NF_Win32_GetSystemMetrics(int nIndex) (requires REAPER 6.24 or later)
int extension_api("NF_Win32_GetSystemMetrics", int nIndex) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.NF_Win32_GetSystemMetrics(integer nIndex)
Int NF_Win32_GetSystemMetrics(Int nIndex)

Equivalent to win32 API GetSystemMetrics(). Note: Only SM_C[XY]SCREEN, SM_C[XY][HV]SCROLL and SM_CYMENU are currently supported on macOS and Linux as of REAPER 6.68. Check the SWELL source code for up-to-date support information (swell-wnd.mm, swell-wnd-generic.cpp).

bool ReaPack_AboutInstalledPackage(PackageEntry* entry)
bool ReaPack_AboutInstalledPackage(PackageEntry entry) (requires REAPER 6.24 or later)
bool extension_api("ReaPack_AboutInstalledPackage", PackageEntry entry) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ReaPack_AboutInstalledPackage(PackageEntry entry)
Boolean ReaPack_AboutInstalledPackage(PackageEntry entry)

Show the about dialog of the given package entry.
The repository index is downloaded asynchronously if the cached copy doesn't exist or is older than one week.

bool ReaPack_AboutRepository(const char* repoName)
bool ReaPack_AboutRepository("repoName") (requires REAPER 6.24 or later)
bool extension_api("ReaPack_AboutRepository", "repoName") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ReaPack_AboutRepository(string repoName)
Boolean ReaPack_AboutRepository(String repoName)

Show the about dialog of the given repository. Returns true if the repository exists in the user configuration.
The repository index is downloaded asynchronously if the cached copy doesn't exist or is older than one week.

bool ReaPack_AddSetRepository(const char* name, const char* url, bool enable, int autoInstall, char* errorOut, int errorOut_sz)
bool ReaPack_AddSetRepository("name", "url", bool enable, int autoInstall, #error) (requires REAPER 6.24 or later)
bool extension_api("ReaPack_AddSetRepository", "name", "url", bool enable, int autoInstall, #error) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string error = reaper.ReaPack_AddSetRepository(string name, string url, boolean enable, integer autoInstall)
(Boolean retval, String name, String url, Boolean enable, Int autoInstall, String errorOut, Int errorOut_sz) = ReaPack_AddSetRepository(name, url, enable, autoInstall, errorOut, errorOut_sz)

Add or modify a repository. Set url to nullptr (or empty string in Lua) to keep the existing URL. Call ReaPack_ProcessQueue(true) when done to process the new list and update the GUI.

autoInstall: usually set to 2 (obey user setting).

void ReaPack_BrowsePackages(const char* filter)
ReaPack_BrowsePackages("filter") (requires REAPER 6.24 or later)
extension_api("ReaPack_BrowsePackages", "filter") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ReaPack_BrowsePackages(string filter)
ReaPack_BrowsePackages(String filter)

Opens the package browser with the given filter string.

int ReaPack_CompareVersions(const char* ver1, const char* ver2, char* errorOut, int errorOut_sz)
int ReaPack_CompareVersions("ver1", "ver2", #error) (requires REAPER 6.24 or later)
int extension_api("ReaPack_CompareVersions", "ver1", "ver2", #error) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer retval, string error = reaper.ReaPack_CompareVersions(string ver1, string ver2)
(Int retval, String ver1, String ver2, String errorOut, Int errorOut_sz) = ReaPack_CompareVersions(ver1, ver2, errorOut, errorOut_sz)

Returns 0 if both versions are equal, a positive value if ver1 is higher than ver2 and a negative value otherwise.

bool ReaPack_EnumOwnedFiles(PackageEntry* entry, int index, char* pathOut, int pathOut_sz, int* sectionsOut, int* typeOut)
bool ReaPack_EnumOwnedFiles(PackageEntry entry, int index, #path, int &sections, int &type) (requires REAPER 6.24 or later)
bool extension_api("ReaPack_EnumOwnedFiles", PackageEntry entry, int index, #path, int &sections, int &type) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string path, integer sections, integer type = reaper.ReaPack_EnumOwnedFiles(PackageEntry entry, integer index)
(Boolean retval, PackageEntry entry, Int index, String pathOut, Int pathOut_sz, Int sectionsOut, Int typeOut) = ReaPack_EnumOwnedFiles(entry, index, pathOut, pathOut_sz, sectionsOut, typeOut)

Enumerate the files owned by the given package. Returns false when there is no more data.

sections: 0=not in action list, &1=main, &2=midi editor, &4=midi inline editor
type: see ReaPack_GetEntryInfo.

bool ReaPack_FreeEntry(PackageEntry* entry)
bool ReaPack_FreeEntry(PackageEntry entry) (requires REAPER 6.24 or later)
bool extension_api("ReaPack_FreeEntry", PackageEntry entry) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.ReaPack_FreeEntry(PackageEntry entry)
Boolean ReaPack_FreeEntry(PackageEntry entry)

Free resources allocated for the given package entry.

bool ReaPack_GetEntryInfo(PackageEntry* entry, char* repoOut, int repoOut_sz, char* catOut, int catOut_sz, char* pkgOut, int pkgOut_sz, char* descOut, int descOut_sz, int* typeOut, char* verOut, int verOut_sz, char* authorOut, int authorOut_sz, int* flagsOut, int* fileCountOut)
bool ReaPack_GetEntryInfo(PackageEntry entry, #repo, #cat, #pkg, #desc, int &type, #ver, #author, int &flags, int &fileCount) (requires REAPER 6.24 or later)
bool extension_api("ReaPack_GetEntryInfo", PackageEntry entry, #repo, #cat, #pkg, #desc, int &type, #ver, #author, int &flags, int &fileCount) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string repo, string cat, string pkg, string desc, integer type, string ver, string author, integer flags, integer fileCount = reaper.ReaPack_GetEntryInfo(PackageEntry entry)
(Boolean retval, PackageEntry entry, String repoOut, Int repoOut_sz, String catOut, Int catOut_sz, String pkgOut, Int pkgOut_sz, String descOut, Int descOut_sz, Int typeOut, String verOut, Int verOut_sz, String authorOut, Int authorOut_sz, Int flagsOut, Int fileCountOut) = ReaPack_GetEntryInfo(entry, repoOut, repoOut_sz, catOut, catOut_sz, pkgOut, pkgOut_sz, descOut, descOut_sz, typeOut, verOut, verOut_sz, authorOut, authorOut_sz, flagsOut, fileCountOut)

Get the repository name, category, package name, package description, package type, the currently installed version, author name, flags (&1=Pinned, &2=BleedingEdge) and how many files are owned by the given package entry.

type: 1=script, 2=extension, 3=effect, 4=data, 5=theme, 6=langpack, 7=webinterface

PackageEntry* ReaPack_GetOwner(const char* fn, char* errorOut, int errorOut_sz)
PackageEntry ReaPack_GetOwner("fn", #error) (requires REAPER 6.24 or later)
PackageEntry extension_api("ReaPack_GetOwner", "fn", #error) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
PackageEntry retval, string error = reaper.ReaPack_GetOwner(string fn)
(PackageEntry retval, String fn, String errorOut, Int errorOut_sz) = ReaPack_GetOwner(fn, errorOut, errorOut_sz)

Returns the package entry owning the given file.
Delete the returned object from memory after use with ReaPack_FreeEntry.

bool ReaPack_GetRepositoryInfo(const char* name, char* urlOut, int urlOut_sz, bool* enabledOut, int* autoInstallOut)
bool ReaPack_GetRepositoryInfo("name", #url, bool &enabled, int &autoInstall) (requires REAPER 6.24 or later)
bool extension_api("ReaPack_GetRepositoryInfo", "name", #url, bool &enabled, int &autoInstall) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string url, boolean enabled, integer autoInstall = reaper.ReaPack_GetRepositoryInfo(string name)
(Boolean retval, String name, String urlOut, Int urlOut_sz, Boolean enabledOut, Int autoInstallOut) = ReaPack_GetRepositoryInfo(name, urlOut, urlOut_sz, enabledOut, autoInstallOut)

Get the infos of the given repository.

autoInstall: 0=manual, 1=when sychronizing, 2=obey user setting

void ReaPack_ProcessQueue(bool refreshUI)
ReaPack_ProcessQueue(bool refreshUI) (requires REAPER 6.24 or later)
extension_api("ReaPack_ProcessQueue", bool refreshUI) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ReaPack_ProcessQueue(boolean refreshUI)
ReaPack_ProcessQueue(Boolean refreshUI)

Run pending operations and save the configuration file. If refreshUI is true the browser and manager windows are guaranteed to be refreshed (otherwise it depends on which operations are in the queue).

bool SNM_AddReceive(MediaTrack* src, MediaTrack* dest, int type)
bool SNM_AddReceive(MediaTrack src, MediaTrack dest, int type) (requires REAPER 6.24 or later)
bool extension_api("SNM_AddReceive", MediaTrack src, MediaTrack dest, int type) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_AddReceive(MediaTrack src, MediaTrack dest, integer type)
Boolean SNM_AddReceive(MediaTrack src, MediaTrack dest, Int type)

[S&M] Deprecated, see CreateTrackSend (v5.15pre1+). Adds a receive. Returns false if nothing updated.
type -1=Default type (user preferences), 0=Post-Fader (Post-Pan), 1=Pre-FX, 2=deprecated, 3=Pre-Fader (Post-FX).
Note: obeys default sends preferences, supports frozen tracks, etc..

bool SNM_AddTCPFXParm(MediaTrack* tr, int fxId, int prmId)
bool SNM_AddTCPFXParm(MediaTrack tr, int fxId, int prmId) (requires REAPER 6.24 or later)
bool extension_api("SNM_AddTCPFXParm", MediaTrack tr, int fxId, int prmId) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_AddTCPFXParm(MediaTrack tr, integer fxId, integer prmId)
Boolean SNM_AddTCPFXParm(MediaTrack tr, Int fxId, Int prmId)

[S&M] Add an FX parameter knob in the TCP. Returns false if nothing updated (invalid parameters, knob already present, etc..)

WDL_FastString* SNM_CreateFastString(const char* str)
WDL_FastString SNM_CreateFastString("str") (requires REAPER 6.24 or later)
WDL_FastString extension_api("SNM_CreateFastString", "str") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
WDL_FastString reaper.SNM_CreateFastString(string str)
WDL_FastString SNM_CreateFastString(String str)

[S&M] Instantiates a new "fast string". You must delete this string, see SNM_DeleteFastString.

void SNM_DeleteFastString(WDL_FastString* str)
SNM_DeleteFastString(WDL_FastString str) (requires REAPER 6.24 or later)
extension_api("SNM_DeleteFastString", WDL_FastString str) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.SNM_DeleteFastString(WDL_FastString str)
SNM_DeleteFastString(WDL_FastString str)

[S&M] Deletes a "fast string" instance.

double SNM_GetDoubleConfigVar(const char* varname, double errvalue)
double SNM_GetDoubleConfigVar("varname", errvalue) (requires REAPER 6.24 or later)
double extension_api("SNM_GetDoubleConfigVar", "varname", errvalue) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
number reaper.SNM_GetDoubleConfigVar(string varname, number errvalue)
Float SNM_GetDoubleConfigVar(String varname, Float errvalue)

[S&M] Returns a floating-point preference (look in project prefs first, then in general prefs). Returns errvalue if failed (e.g. varname not found).

const char* SNM_GetFastString(WDL_FastString* str)
bool SNM_GetFastString(#retval, WDL_FastString str) (requires REAPER 6.24 or later)
bool extension_api("SNM_GetFastString", #retval, WDL_FastString str) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string reaper.SNM_GetFastString(WDL_FastString str)
String SNM_GetFastString(WDL_FastString str)

[S&M] Gets the "fast string" content.

int SNM_GetFastStringLength(WDL_FastString* str)
int SNM_GetFastStringLength(WDL_FastString str) (requires REAPER 6.24 or later)
int extension_api("SNM_GetFastStringLength", WDL_FastString str) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.SNM_GetFastStringLength(WDL_FastString str)
Int SNM_GetFastStringLength(WDL_FastString str)

[S&M] Gets the "fast string" length.

int SNM_GetIntConfigVar(const char* varname, int errvalue)
int SNM_GetIntConfigVar("varname", int errvalue) (requires REAPER 6.24 or later)
int extension_api("SNM_GetIntConfigVar", "varname", int errvalue) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.SNM_GetIntConfigVar(string varname, integer errvalue)
Int SNM_GetIntConfigVar(String varname, Int errvalue)

[S&M] Returns an integer preference (look in project prefs first, then in general prefs). Returns errvalue if failed (e.g. varname not found).

bool SNM_GetLongConfigVar(const char* varname, int* highOut, int* lowOut)
bool SNM_GetLongConfigVar("varname", int &high, int &low) (requires REAPER 6.24 or later)
bool extension_api("SNM_GetLongConfigVar", "varname", int &high, int &low) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, integer high, integer low = reaper.SNM_GetLongConfigVar(string varname)
(Boolean retval, String varname, Int highOut, Int lowOut) = SNM_GetLongConfigVar(varname, highOut, lowOut)

[S&M] Reads a 64-bit integer preference split in two 32-bit integers (look in project prefs first, then in general prefs). Returns false if failed (e.g. varname not found).

MediaItem_Take* SNM_GetMediaItemTakeByGUID(ReaProject* project, const char* guid)
MediaItem_Take SNM_GetMediaItemTakeByGUID(ReaProject project, "guid") (requires REAPER 6.24 or later)
MediaItem_Take extension_api("SNM_GetMediaItemTakeByGUID", ReaProject project, "guid") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
MediaItem_Take reaper.SNM_GetMediaItemTakeByGUID(ReaProject project, string guid)
MediaItem_Take SNM_GetMediaItemTakeByGUID(ReaProject project, String guid)

[S&M] Gets a take by GUID as string. The GUID must be enclosed in braces {}. To get take GUID as string, see BR_GetMediaItemTakeGUID

bool SNM_GetProjectMarkerName(ReaProject* proj, int num, bool isrgn, WDL_FastString* name)
bool SNM_GetProjectMarkerName(ReaProject proj, int num, bool isrgn, WDL_FastString name) (requires REAPER 6.24 or later)
bool extension_api("SNM_GetProjectMarkerName", ReaProject proj, int num, bool isrgn, WDL_FastString name) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_GetProjectMarkerName(ReaProject proj, integer num, boolean isrgn, WDL_FastString name)
Boolean SNM_GetProjectMarkerName(ReaProject proj, Int num, Boolean isrgn, WDL_FastString name)

[S&M] Gets a marker/region name. Returns true if marker/region found.

bool SNM_GetSetObjectState(void* obj, WDL_FastString* state, bool setnewvalue, bool wantminimalstate)
bool SNM_GetSetObjectState(void* obj, WDL_FastString state, bool setnewvalue, bool wantminimalstate) (requires REAPER 6.24 or later)
bool extension_api("SNM_GetSetObjectState", void* obj, WDL_FastString state, bool setnewvalue, bool wantminimalstate) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_GetSetObjectState(identifier obj, WDL_FastString state, boolean setnewvalue, boolean wantminimalstate)
Boolean SNM_GetSetObjectState(void obj, WDL_FastString state, Boolean setnewvalue, Boolean wantminimalstate)

[S&M] Gets or sets the state of a track, an item or an envelope. The state chunk size is unlimited. Returns false if failed.
When getting a track state (and when you are not interested in FX data), you can use wantminimalstate=true to radically reduce the length of the state. Do not set such minimal states back though, this is for read-only applications!
Note: unlike the native GetSetObjectState, calling to FreeHeapPtr() is not required.

bool SNM_GetSetSourceState(MediaItem* item, int takeidx, WDL_FastString* state, bool setnewvalue)
bool SNM_GetSetSourceState(MediaItem item, int takeidx, WDL_FastString state, bool setnewvalue) (requires REAPER 6.24 or later)
bool extension_api("SNM_GetSetSourceState", MediaItem item, int takeidx, WDL_FastString state, bool setnewvalue) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_GetSetSourceState(MediaItem item, integer takeidx, WDL_FastString state, boolean setnewvalue)
Boolean SNM_GetSetSourceState(MediaItem item, Int takeidx, WDL_FastString state, Boolean setnewvalue)

[S&M] Gets or sets a take source state. Returns false if failed. Use takeidx=-1 to get/alter the active take.
Note: this function does not use a MediaItem_Take* param in order to manage empty takes (i.e. takes with MediaItem_Take*==NULL), see SNM_GetSetSourceState2.

bool SNM_GetSetSourceState2(MediaItem_Take* take, WDL_FastString* state, bool setnewvalue)
bool SNM_GetSetSourceState2(MediaItem_Take take, WDL_FastString state, bool setnewvalue) (requires REAPER 6.24 or later)
bool extension_api("SNM_GetSetSourceState2", MediaItem_Take take, WDL_FastString state, bool setnewvalue) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_GetSetSourceState2(MediaItem_Take take, WDL_FastString state, boolean setnewvalue)
Boolean SNM_GetSetSourceState2(MediaItem_Take take, WDL_FastString state, Boolean setnewvalue)

[S&M] Gets or sets a take source state. Returns false if failed.
Note: this function cannot deal with empty takes, see SNM_GetSetSourceState.

bool SNM_GetSourceType(MediaItem_Take* take, WDL_FastString* type)
bool SNM_GetSourceType(MediaItem_Take take, WDL_FastString type) (requires REAPER 6.24 or later)
bool extension_api("SNM_GetSourceType", MediaItem_Take take, WDL_FastString type) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_GetSourceType(MediaItem_Take take, WDL_FastString type)
Boolean SNM_GetSourceType(MediaItem_Take take, WDL_FastString type)

[S&M] Deprecated, see GetMediaSourceType. Gets the source type of a take. Returns false if failed (e.g. take with empty source, etc..)

bool SNM_MoveOrRemoveTrackFX(MediaTrack* tr, int fxId, int what)
bool SNM_MoveOrRemoveTrackFX(MediaTrack tr, int fxId, int what) (requires REAPER 6.24 or later)
bool extension_api("SNM_MoveOrRemoveTrackFX", MediaTrack tr, int fxId, int what) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_MoveOrRemoveTrackFX(MediaTrack tr, integer fxId, integer what)
Boolean SNM_MoveOrRemoveTrackFX(MediaTrack tr, Int fxId, Int what)

[S&M] Deprecated, see TakeFX_/TrackFX_ CopyToTrack/Take, TrackFX/TakeFX _Delete (v5.95pre2+). Move or removes a track FX. Returns true if tr has been updated.
fxId: fx index in chain or -1 for the selected fx. what: 0 to remove, -1 to move fx up in chain, 1 to move fx down in chain.

bool SNM_ReadMediaFileTag(const char* fn, const char* tag, char* tagvalOut, int tagvalOut_sz)
bool SNM_ReadMediaFileTag("fn", "tag", #tagval) (requires REAPER 6.24 or later)
bool extension_api("SNM_ReadMediaFileTag", "fn", "tag", #tagval) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean retval, string tagval = reaper.SNM_ReadMediaFileTag(string fn, string tag)
(Boolean retval, String fn, String tag, String tagvalOut, Int tagvalOut_sz) = SNM_ReadMediaFileTag(fn, tag, tagvalOut, tagvalOut_sz)

[S&M] Reads a media file tag. Supported tags: "artist", "album", "genre", "comment", "title", "track" (track number) or "year". Returns false if tag was not found. See SNM_TagMediaFile.

bool SNM_RemoveReceive(MediaTrack* tr, int rcvidx)
bool SNM_RemoveReceive(MediaTrack tr, int rcvidx) (requires REAPER 6.24 or later)
bool extension_api("SNM_RemoveReceive", MediaTrack tr, int rcvidx) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_RemoveReceive(MediaTrack tr, integer rcvidx)
Boolean SNM_RemoveReceive(MediaTrack tr, Int rcvidx)

[S&M] Deprecated, see RemoveTrackSend (v5.15pre1+). Removes a receive. Returns false if nothing updated.

bool SNM_RemoveReceivesFrom(MediaTrack* tr, MediaTrack* srctr)
bool SNM_RemoveReceivesFrom(MediaTrack tr, MediaTrack srctr) (requires REAPER 6.24 or later)
bool extension_api("SNM_RemoveReceivesFrom", MediaTrack tr, MediaTrack srctr) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_RemoveReceivesFrom(MediaTrack tr, MediaTrack srctr)
Boolean SNM_RemoveReceivesFrom(MediaTrack tr, MediaTrack srctr)

[S&M] Removes all receives from srctr. Returns false if nothing updated.

int SNM_SelectResourceBookmark(const char* name)
int SNM_SelectResourceBookmark("name") (requires REAPER 6.24 or later)
int extension_api("SNM_SelectResourceBookmark", "name") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.SNM_SelectResourceBookmark(string name)
Int SNM_SelectResourceBookmark(String name)

[S&M] Select a bookmark of the Resources window. Returns the related bookmark id (or -1 if failed).

bool SNM_SetDoubleConfigVar(const char* varname, double newvalue)
bool SNM_SetDoubleConfigVar("varname", newvalue) (requires REAPER 6.24 or later)
bool extension_api("SNM_SetDoubleConfigVar", "varname", newvalue) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_SetDoubleConfigVar(string varname, number newvalue)
Boolean SNM_SetDoubleConfigVar(String varname, Float newvalue)

[S&M] Sets a floating-point preference (look in project prefs first, then in general prefs). Returns false if failed (e.g. varname not found or newvalue out of range).

WDL_FastString* SNM_SetFastString(WDL_FastString* str, const char* newstr)
WDL_FastString SNM_SetFastString(WDL_FastString str, "newstr") (requires REAPER 6.24 or later)
WDL_FastString extension_api("SNM_SetFastString", WDL_FastString str, "newstr") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
WDL_FastString reaper.SNM_SetFastString(WDL_FastString str, string newstr)
WDL_FastString SNM_SetFastString(WDL_FastString str, String newstr)

[S&M] Sets the "fast string" content. Returns str for facility.

bool SNM_SetIntConfigVar(const char* varname, int newvalue)
bool SNM_SetIntConfigVar("varname", int newvalue) (requires REAPER 6.24 or later)
bool extension_api("SNM_SetIntConfigVar", "varname", int newvalue) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_SetIntConfigVar(string varname, integer newvalue)
Boolean SNM_SetIntConfigVar(String varname, Int newvalue)

[S&M] Sets an integer preference (look in project prefs first, then in general prefs). Returns false if failed (e.g. varname not found or newvalue out of range).

bool SNM_SetLongConfigVar(const char* varname, int newHighValue, int newLowValue)
bool SNM_SetLongConfigVar("varname", int newHighValue, int newLowValue) (requires REAPER 6.24 or later)
bool extension_api("SNM_SetLongConfigVar", "varname", int newHighValue, int newLowValue) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_SetLongConfigVar(string varname, integer newHighValue, integer newLowValue)
Boolean SNM_SetLongConfigVar(String varname, Int newHighValue, Int newLowValue)

[S&M] Sets a 64-bit integer preference from two 32-bit integers (look in project prefs first, then in general prefs). Returns false if failed (e.g. varname not found).

bool SNM_SetProjectMarker(ReaProject* proj, int num, bool isrgn, double pos, double rgnend, const char* name, int color)
bool SNM_SetProjectMarker(ReaProject proj, int num, bool isrgn, pos, rgnend, "name", int color) (requires REAPER 6.24 or later)
bool extension_api("SNM_SetProjectMarker", ReaProject proj, int num, bool isrgn, pos, rgnend, "name", int color) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_SetProjectMarker(ReaProject proj, integer num, boolean isrgn, number pos, number rgnend, string name, integer color)
Boolean SNM_SetProjectMarker(ReaProject proj, Int num, Boolean isrgn, Float pos, Float rgnend, String name, Int color)

[S&M] Deprecated, see SetProjectMarker4 -- Same function as SetProjectMarker3() except it can set empty names "".

bool SNM_SetStringConfigVar(const char* varname, const char* newvalue)
bool SNM_SetStringConfigVar("varname", "newvalue") (requires REAPER 6.24 or later)
bool extension_api("SNM_SetStringConfigVar", "varname", "newvalue") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_SetStringConfigVar(string varname, string newvalue)
Boolean SNM_SetStringConfigVar(String varname, String newvalue)

[S&M] Sets a string preference (general prefs only). Returns false if failed (e.g. varname not found or value too long). See get_config_var_string.

bool SNM_TagMediaFile(const char* fn, const char* tag, const char* tagval)
bool SNM_TagMediaFile("fn", "tag", "tagval") (requires REAPER 6.24 or later)
bool extension_api("SNM_TagMediaFile", "fn", "tag", "tagval") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
boolean reaper.SNM_TagMediaFile(string fn, string tag, string tagval)
Boolean SNM_TagMediaFile(String fn, String tag, String tagval)

[S&M] Tags a media file thanks to TagLib. Supported tags: "artist", "album", "genre", "comment", "title", "track" (track number) or "year". Use an empty tagval to clear a tag. When a file is opened in REAPER, turn it offline before using this function. Returns false if nothing updated. See SNM_ReadMediaFileTag.

void SNM_TieResourceSlotActions(int bookmarkId)
SNM_TieResourceSlotActions(int bookmarkId) (requires REAPER 6.24 or later)
extension_api("SNM_TieResourceSlotActions", int bookmarkId) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.SNM_TieResourceSlotActions(integer bookmarkId)
SNM_TieResourceSlotActions(Int bookmarkId)

[S&M] Attach Resources slot actions to a given bookmark.

void SN_FocusMIDIEditor()
SN_FocusMIDIEditor() (requires REAPER 6.24 or later)
extension_api("SN_FocusMIDIEditor") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.SN_FocusMIDIEditor()
SN_FocusMIDIEditor()

Focuses the active/open MIDI editor.

const char* ULT_GetMediaItemNote(MediaItem* item)
bool ULT_GetMediaItemNote(#retval, MediaItem item) (requires REAPER 6.24 or later)
bool extension_api("ULT_GetMediaItemNote", #retval, MediaItem item) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
string reaper.ULT_GetMediaItemNote(MediaItem item)
String ULT_GetMediaItemNote(MediaItem item)

[ULT] Deprecated, see GetSetMediaItemInfo_String (v5.95+). Get item notes.

void ULT_SetMediaItemNote(MediaItem* item, const char* note)
ULT_SetMediaItemNote(MediaItem item, "note") (requires REAPER 6.24 or later)
extension_api("ULT_SetMediaItemNote", MediaItem item, "note") (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.ULT_SetMediaItemNote(MediaItem item, string note)
ULT_SetMediaItemNote(MediaItem item, String note)

[ULT] Deprecated, see GetSetMediaItemInfo_String (v5.95+). Set item notes.

AudioWriter* Xen_AudioWriter_Create(const char* filename, int numchans, int samplerate)
AudioWriter Xen_AudioWriter_Create("filename", int numchans, int samplerate) (requires REAPER 6.24 or later)
AudioWriter extension_api("Xen_AudioWriter_Create", "filename", int numchans, int samplerate) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
AudioWriter reaper.Xen_AudioWriter_Create(string filename, integer numchans, integer samplerate)
AudioWriter Xen_AudioWriter_Create(String filename, Int numchans, Int samplerate)

Creates writer for 32 bit floating point WAV

void Xen_AudioWriter_Destroy(AudioWriter* writer)
Xen_AudioWriter_Destroy(AudioWriter writer) (requires REAPER 6.24 or later)
extension_api("Xen_AudioWriter_Destroy", AudioWriter writer) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
reaper.Xen_AudioWriter_Destroy(AudioWriter writer)
Xen_AudioWriter_Destroy(AudioWriter writer)

Destroys writer

int Xen_AudioWriter_Write(AudioWriter* writer, int numframes, void* data, int offset)
int Xen_AudioWriter_Write(AudioWriter writer, int numframes, void* data, int offset) (requires REAPER 6.24 or later)
int extension_api("Xen_AudioWriter_Write", AudioWriter writer, int numframes, void* data, int offset) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.Xen_AudioWriter_Write(AudioWriter writer, integer numframes, identifier data, integer offset)
Int Xen_AudioWriter_Write(AudioWriter writer, Int numframes, void data, Int offset)

Write interleaved audio data to disk

int Xen_GetMediaSourceSamples(PCM_source* src, void* destbuf, int destbufoffset, int numframes, int numchans, double samplerate, double sourceposition)
int Xen_GetMediaSourceSamples(PCM_source src, void* destbuf, int destbufoffset, int numframes, int numchans, samplerate, sourceposition) (requires REAPER 6.24 or later)
int extension_api("Xen_GetMediaSourceSamples", PCM_source src, void* destbuf, int destbufoffset, int numframes, int numchans, samplerate, sourceposition) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.Xen_GetMediaSourceSamples(PCM_source src, identifier destbuf, integer destbufoffset, integer numframes, integer numchans, number samplerate, number sourceposition)
Int Xen_GetMediaSourceSamples(PCM_source src, void destbuf, Int destbufoffset, Int numframes, Int numchans, Float samplerate, Float sourceposition)

Get interleaved audio data from media source

int Xen_StartSourcePreview(PCM_source* source, double gain, bool loop, int* outputchanindexInOptional)
int Xen_StartSourcePreview(PCM_source source, gain, bool loop, optional int outputchanindexIn) (requires REAPER 6.24 or later)
int extension_api("Xen_StartSourcePreview", PCM_source source, gain, bool loop, optional int outputchanindexIn) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.Xen_StartSourcePreview(PCM_source source, number gain, boolean loop, optional integer outputchanindexIn)
(Int retval, PCM_source source, Float gain, Boolean loop, Int outputchanindexInOptional) = Xen_StartSourcePreview(source, gain, loop, outputchanindexInOptional)

Start audio preview of a PCM_source. Returns id of a preview handle that can be provided to Xen_StopSourcePreview.
If the given PCM_source does not belong to an existing MediaItem/Take, it will be deleted by the preview system when the preview is stopped.

int Xen_StopSourcePreview(int preview_id)
int Xen_StopSourcePreview(int preview_id) (requires REAPER 6.24 or later)
int extension_api("Xen_StopSourcePreview", int preview_id) (legacy syntax, also useful for allowing script to run when third-party extension is not installed)
integer reaper.Xen_StopSourcePreview(integer preview_id)
Int Xen_StopSourcePreview(Int preview_id)

Stop audio preview. id -1 stops all.

ReaScript/EEL Built-in Function List

abs(value)

Returns the absolute value of the parameter.

acos(value)

Returns the arc cosine of the value specified (return value is in radians). If the parameter is not between -1.0 and 1.0 inclusive, the return value is undefined.

asin(value)

Returns the arc sine of the value specified (return value is in radians). If the parameter is not between -1.0 and 1.0 inclusive, the return value is undefined.

atan(value)

Returns the arc tangent of the value specified (return value is in radians). If the parameter is not between -1.0 and 1.0 inclusive, the return value is undefined.

atan2(numerator,denominator)

Returns the arc tangent of the numerator divided by the denominator, allowing the denominator to be 0, and using their signs to produce a more meaningful result.

atexit("code")

Adds code to be executed when the script finishes or is ended by the user. Typically used to clean up after the user terminates defer() or runloop() code.

ceil(value)

Returns the value rounded to the next highest integer (ceil(3.1)==4, ceil(-3.9)==-3).

convolve_c(dest,src,size)

Multiplies each of size complex pairs in dest by the complex pairs in src. Often used for convolution.

cos(angle)

Returns the cosine of the angle specified (specified in radians).

defer("code")

Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to runloop().
Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.

eval("code")

Executes code passed in. Code can use functions, but functions created in code can't be used elsewhere.

exp(exponent)

Returns the number e ($e, approximately 2.718) raised to the parameter-th power. This function is significantly faster than pow() or the ^ operator.

extension_api("function_name"[,...])

Used to call functions exported by extension plugins. The first parameter must be the exported function name, then its own parameters (as if the function was called directly).

fclose(fp)

Closes a file previously opened with fopen().

feof(fp)

Returns nonzero if the file fp is at the end of file.

fflush(fp)

If file fp is open for writing, flushes out any buffered data to disk.

fft(buffer,size)

Performs a FFT on the data in the local memory buffer at the offset specified by the first parameter. The size of the FFT is specified by the second parameter, which must be 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, or 32768. The outputs are permuted, so if you plan to use them in-order, call fft_permute(buffer, size) before and fft_ipermute(buffer,size) after your in-order use. Your inputs or outputs will need to be scaled down by 1/size, if used.
Note that fft()/ifft() require real / imaginary input pairs, so a 256 point FFT actually works with 512 items.
Note that fft()/ifft() must NOT cross a 65,536 item boundary, so be sure to specify the offset accordingly.

fft_ipermute(buffer,size)

Permute the input for ifft(), taking bands from in-order to the order ifft() requires. See fft() for more information.

fft_permute(buffer,size)

Permute the output of fft() to have bands in-order. See fft() for more information.

fft_real(buffer,size)

Performs an FFT, but takes size input samples and produces size/2 complex output pairs. Usually used along with fft_permute(size/2). Inputs/outputs will need to be scaled by 0.5/size.

fgetc(fp)

Reads a character from file fp, returns -1 if EOF.

fgets(fp,#str)

Reads a line from file fp into #str. Returns length of #str read.

floor(value)

Returns the value rounded to the next lowest integer (floor(3.9)==3, floor(-3.1)==-4).

fopen("fn","mode")

Opens a file "fn" with mode "mode". For read, use "r" or "rb", write "w" or "wb". Returns a positive integer on success.

fprintf(fp,"format"[,...])

Formats a string and writes it to file fp. For more information on format specifiers, see sprintf(). Returns bytes written to file.

fread(fp,#str,length)

Reads from file fp into #str, up to length bytes. Returns actual length read, or negative if error.

freembuf(address)

Hints the runtime that memory above the address specified may no longer be used. The runtime may, at its leisure, choose to lose the contents of memory above the address specified.

fseek(fp,offset,whence)

Seeks file fp, offset bytes from whence reference. Whence negative specifies start of file, positive whence specifies end of file, and zero whence specifies current file position.

ftell(fp)

Retunrs the current file position.

fwrite(fp,#str,len)

Writes up to len characters of #str to file fp. If len is less than 1, the full contents of #str will be written. Returns the number of bytes written to file.

get_action_context(#filename,sectionID,cmdID,mode,resolution,val,contextstr)

Queries contextual information about the script, typically MIDI/OSC input values.
Returns true if a new value has been updated.
val will be set to a relative or absolute value depending on mode (=0: absolute mode, >0: relative modes).
resolution=127 for 7-bit resolution, =16383 for 14-bit resolution.
sectionID, and cmdID will be set to -1 if the script is not part of the action list.
mode, resolution and val will be set to -1 if the script was not triggered via MIDI/OSC.
contextstr may be empty or one of:

  • midi:XX[:YY] (one or two bytes hex)
  • [wheel|hwheel|mtvert|mthorz|mtzoom|mtrot|mediakbd]:flags
  • key:flags:keycode
  • osc:/msg[:f=FloatValue|:s=StringValue]
  • KBD_OnMainActionEx

(flags may include V=virtkey, S=shift, A=alt/option, C=control/command, W=win/control)

gfx VARIABLES

The following global variables are special and will be used by the graphics system:

  • gfx_r - current red component (0..1) used by drawing operations.
  • gfx_g - current green component (0..1) used by drawing operations.
  • gfx_b - current blue component (0..1) used by drawing operations.
  • gfx_a2 - current alpha component (0..1) used by drawing operations when writing solid colors (normally ignored but useful when creating transparent images).
  • gfx_a - alpha for drawing (1=normal).
  • gfx_mode - blend mode for drawing. Set mode to 0 for default options. Add 1.0 for additive blend mode (if you wish to do subtractive, set gfx_a to negative and use gfx_mode as additive). Add 2.0 to disable source alpha for gfx_blit(). Add 4.0 to disable filtering for gfx_blit().
  • gfx_w - width of the UI framebuffer.
  • gfx_h - height of the UI framebuffer.
  • gfx_x - current graphics position X. Some drawing functions use as start position and update.
  • gfx_y - current graphics position Y. Some drawing functions use as start position and update.
  • gfx_clear - if greater than -1.0, framebuffer will be cleared to that color. the color for this one is packed RGB (0..255), i.e. red+green*256+blue*65536. The default is 0 (black).
  • gfx_dest - destination for drawing operations, -1 is main framebuffer, set to 0..1024-1 to have drawing operations go to an offscreen buffer (or loaded image).
  • gfx_texth - the (READ-ONLY) height of a line of text in the current font. Do not modify this variable.
  • gfx_ext_retina - to support hidpi/retina, callers should set to 1.0 on initialization, this value will be updated to value greater than 1.0 (such as 2.0) if retina/hidpi. On macOS gfx_w/gfx_h/etc will be doubled, but on other systems gfx_w/gfx_h will remain the same and gfx_ext_retina is a scaling hint for drawing.
  • mouse_x - current X coordinate of the mouse relative to the graphics window.
  • mouse_y - current Y coordinate of the mouse relative to the graphics window.
  • mouse_wheel - wheel position, will change typically by 120 or a multiple thereof, the caller should clear the state to 0 after reading it.
  • mouse_hwheel - horizontal wheel positions, will change typically by 120 or a multiple thereof, the caller should clear the state to 0 after reading it.
  • mouse_cap - a bitfield of mouse and keyboard modifier state. Note that a script must call gfx_getchar() at least once in order to get modifier state when the mouse is not captured by the window. Bitfield bits:
    • 1: left mouse button
    • 2: right mouse button
    • 4: Control key
    • 8: Shift key
    • 16: Alt key
    • 32: Windows key
    • 64: middle mouse button
gfx_arc(x,y,r,ang1,ang2[,antialias])

Draws an arc of the circle centered at x,y, with ang1/ang2 being specified in radians.

gfx_blit(source[, scale, rotation, srcx, srcy, srcw, srch, destx, desty, destw, desth, rotxoffs, rotyoffs])

Copies from source (-1 = main framebuffer, or an image from gfx_loadimg() etc), using current opacity and copy mode (set with gfx_a, gfx_mode).
If destx/desty are not specified, gfx_x/gfx_y will be used as the destination position.
scale (1.0 is unscaled) will be used only if destw/desth are not specified.
rotation is an angle in radians
srcx/srcy/srcw/srch specify the source rectangle (if omitted srcw/srch default to image size)
destx/desty/destw/desth specify destination rectangle (if not specified destw/desth default to srcw/srch * scale).

gfx_blitext(source,coordinatelist,rotation)

Deprecated, use gfx_blit instead.

gfx_blurto(x,y)

Blurs the region of the screen between gfx_x,gfx_y and x,y, and updates gfx_x,gfx_y to x,y.

gfx_circle(x,y,r[,fill,antialias])

Draws a circle, optionally filling/antialiasing.

gfx_clienttoscreen(x,y)

Converts client coordinates x,y to screen coordinates.

gfx_deltablit(srcimg,srcs,srct,srcw,srch,destx,desty,destw,desth,dsdx,dtdx,dsdy,dtdy,dsdxdy,dtdxdy[,usecliprect=1])

Blits from srcimg(srcx,srcy,srcw,srch) to destination (destx,desty,destw,desth). Source texture coordinates are s/t, dsdx represents the change in s coordinate for each x pixel, dtdy represents the change in t coordinate for each y pixel, etc. dsdxdy represents the change in dsdx for each line. If usecliprect is specified and 0, then srcw/srch are ignored.

gfx_dock(v[,wx,wy,ww,wh])

Call with v=-1 to query docked state, otherwise v>=0 to set docked state. State is &1 if docked, second byte is docker index (or last docker index if undocked). If wx-wh are specified, they will be filled with the undocked window position/size

gfx_drawchar(char)

Draws the character (can be a numeric ASCII code as well), to gfx_x, gfx_y, and moves gfx_x over by the size of the character.

gfx_drawnumber(n,ndigits)

Draws the number n with ndigits of precision to gfx_x, gfx_y, and updates gfx_x to the right side of the drawing. The text height is gfx_texth.

gfx_drawstr("str"[,flags,right,bottom])

Draws a string at gfx_x, gfx_y, and updates gfx_x/gfx_y so that subsequent draws will occur in a similar place.

If flags, right ,bottom passed in:

  • flags&1: center horizontally
  • flags&2: right justify
  • flags&4: center vertically
  • flags&8: bottom justify
  • flags&256: ignore right/bottom, otherwise text is clipped to (gfx_x, gfx_y, right, bottom\)
gfx_getchar([char, unichar])

If char is 0 or omitted, returns a character from the keyboard queue, or 0 if no character is available, or -1 if the graphics window is not open. If char is specified and nonzero, that character's status will be checked, and the function will return greater than 0 if it is pressed. Note that calling gfx_getchar() at least once causes mouse_cap to reflect keyboard modifiers even when the mouse is not captured.Common values are standard ASCII, such as 'a', 'A', '=' and '1', but for many keys multi-byte values are used, including 'home', 'up', 'down', 'left', 'rght', 'f1'.. 'f12', 'pgup', 'pgdn', 'ins', and 'del'. Modified and special keys can also be returned, including:

  • Ctrl/Cmd+A..Ctrl+Z as 1..26
  • Ctrl/Cmd+Alt+A..Z as 257..282
  • Alt+A..Z as 'A'+256..'Z'+256
  • 27 for ESC
  • 13 for Enter
  • ' ' for space
  • 65536 for query of special flags, returns: &1 (supported), &2=window has focus, &4=window is visible, &8=mouse click would hit window. 65537 queries special flags but does not do the mouse click hit testing (faster).
  • If unichar is specified, it will be set to the unicode value of the key if available (and the return value may be the unicode value or a raw key value as described above, depending). If unichar is not specified, unicode codepoints greater than 255 will be returned as 'u'<<24 + value
gfx_getdropfile(idx[,#str])

Enumerates any drag/dropped files. call gfx_dropfile(-1) to clear the list when finished. Returns 1 if idx is valid, 0 if idx is out of range.

gfx_getfont([#str])

Returns current font index. If a string is passed, it will receive the actual font face used by this font, if available.

gfx_getimgdim(image,w,h)

Retreives the dimensions of image (representing a filename: index number) into w and h. Sets these values to 0 if an image failed loading (or if the filename index is invalid).

gfx_getpixel(r,g,b)

Gets the value of the pixel at gfx_x,gfx_y into r,g,b.

gfx_gradrect(x,y,w,h, r,g,b,a[, drdx, dgdx, dbdx, dadx, drdy, dgdy, dbdy, dady])

Fills a gradient rectangle with the color and alpha specified. drdx-dadx reflect the adjustment (per-pixel) applied for each pixel moved to the right, drdy-dady are the adjustment applied for each pixel moved toward the bottom. Normally drdx=adjustamount/w, drdy=adjustamount/h, etc.

gfx_init("name"[,width,height,dockstate,xpos,ypos])

Initializes the graphics window with title name. Suggested width and height can be specified. If window is already open, a non-empty name will re-title window, or an empty title will resize window.

Once the graphics window is open, gfx_update() should be called periodically.

gfx_line(x,y,x2,y2[,aa])

Draws a line from x,y to x2,y2, and if aa is not specified or 0.5 or greater, it will be antialiased.

gfx_lineto(x,y[,aa])

Draws a line from gfx_x,gfx_y to x,y. If aa is 0.5 or greater, then antialiasing is used. Updates gfx_x and gfx_y to x,y.

gfx_loadimg(image,"filename")

Load image from filename into slot 0..1024-1 specified by image. Returns the image index if success, otherwise -1 if failure. The image will be resized to the dimensions of the image file.

gfx_measurechar(character,&w,&h)

Measures the drawing dimensions of a character with the current font (as set by gfx_setfont).

gfx_measurestr("str",&w,&h)

Measures the drawing dimensions of a string with the current font (as set by gfx_setfont).

gfx_muladdrect(x,y,w,h,mul_r,mul_g,mul_b[,mul_a,add_r,add_g,add_b,add_a])

Multiplies each pixel by mul_* and adds add_*, and updates in-place. Useful for changing brightness/contrast, or other effects.

gfx_printf("format"[, ...])

Formats and draws a string at gfx_x, gfx_y, and updates gfx_x/gfx_y accordingly (the latter only if the formatted string contains newline). For more information on format strings, see sprintf()

gfx_quit()

Closes the graphics window.

gfx_rect(x,y,w,h[,filled])

Fills a rectangle at x,y, w,h pixels in dimension, filled by default.

gfx_rectto(x,y)

Fills a rectangle from gfx_x,gfx_y to x,y. Updates gfx_x,gfx_y to x,y.

gfx_roundrect(x,y,w,h,radius[,antialias])

Draws a rectangle with rounded corners.

gfx_screentoclient(x,y)

Converts screen coordinates x,y to client coordinates.

gfx_set(r[,g,b,a,mode,dest,a2])

Sets gfx_r/gfx_g/gfx_b/gfx_a/gfx_mode/gfx_a2, sets gfx_dest if final parameter specified

gfx_setcursor(resource_id,custom_cursor_name)

Specify 0 resource_id and custom_cursor_name from https://www.reaper.fm/sdk/cursors/cursors.php (e.g. 'arrow') to set the cursor. Alternatively can specify resource_id for a Windows cursor or built-in REAPER cursor.

gfx_setfont(idx[,"fontface", sz, flags])

Can select a font and optionally configure it. idx=0 for default bitmapped font, no configuration is possible for this font. idx=1..16 for a configurable font, specify fontface such as "Arial", sz of 8-100, and optionally specify flags, which is a multibyte character, which can include 'i' for italics, 'u' for underline, or 'b' for bold. These flags may or may not be supported depending on the font and OS. After calling gfx_setfont(), gfx_texth may be updated to reflect the new average line height.

gfx_setimgdim(image,w,h)

Resize image referenced by index 0..1024-1, width and height must be 0-8192. The contents of the image will be undefined after the resize.

gfx_setpixel(r,g,b)

Writes a pixel of r,g,b to gfx_x,gfx_y.

gfx_showmenu("str")

Shows a popup menu at gfx_x,gfx_y. str is a list of fields separated by | characters. Each field represents a menu item.
Fields can start with special characters:

# : grayed out
! : checked
> : this menu item shows a submenu
< : last item in the current submenu

An empty field will appear as a separator in the menu. gfx_showmenu returns 0 if the user selected nothing from the menu, 1 if the first field is selected, etc.
Example:

gfx_showmenu("first item, followed by separator||!second item, checked|>third item which spawns a submenu|#first item in submenu, grayed out|<second and last item in submenu|fourth item in top menu")

gfx_transformblit(srcimg,destx,desty,destw,desth,div_w,div_h,table)

Blits to destination at (destx,desty), size (destw,desth). div_w and div_h should be 2..64, and table should point to a table of 2*div_w*div_h values (this table must not cross a 65536 item boundary). Each pair in the table represents a S,T coordinate in the source image, and the table is treated as a left-right, top-bottom list of texture coordinates, which will then be rendered to the destination.

gfx_triangle(x1,y1,x2,y2,x3,y3[x4,y4...])

Draws a filled triangle, or any convex polygon.

gfx_update()

Updates the graphics display, if opened

ifft(buffer,size)

Perform an inverse FFT. For more information see fft().

ifft_real(buffer,size)

Performs an inverse FFT, but takes size/2 complex input pairs and produces size real output values. Usually used along with fft_ipermute(size/2).

invsqrt(value)

Returns a fast inverse square root (1/sqrt(x)) approximation of the parameter.

log(value)

Returns the natural logarithm (base e) of the parameter. If the value is not greater than 0, the return value is undefined.

log10(value)

Returns the base-10 logarithm of the parameter. If the value is not greater than 0, the return value is undefined.

loop(count,expression)

Evaluates count once, and then executes expression count, but not more than 1048576, times.

match("needle","haystack"[, ...])

Searches for the first parameter in the second parameter, using a simplified regular expression syntax.

  • * = match 0 or more characters
  • *? = match 0 or more characters, lazy
  • + = match 1 or more characters
  • +? = match 1 or more characters, lazy
  • ? = match one character

You can also use format specifiers to match certain types of data, and optionally put that into a variable:

  • %s means 1 or more chars
  • %0s means 0 or more chars
  • %5s means exactly 5 chars
  • %5-s means 5 or more chars
  • %-10s means 1-10 chars
  • %3-5s means 3-5 chars
  • %0-5s means 0-5 chars
  • %x, %d, %u, and %f are available for use similarly
  • %c can be used, but can't take any length modifiers
  • Use uppercase (%S, %D, etc) for lazy matching

See also sprintf() for other notes, including specifying direct variable references via {}.

matchi("needle","haystack"[, ...])

Case-insensitive version of match().

max(&value,&value)

Returns (by reference) the maximum value of the two parameters. Since max() returns by reference, expressions such as max(x,y) = 5 are possible.

mem_get_values(offset, ...)

Reads values from memory starting at offset into variables specified. Slower than regular memory reads for less than a few variables, faster for more than a few. Undefined behavior if used with more than 32767 variables.

mem_insert_shuffle(buf,len,value)

Shuffles contents of buf right by 1, inserts value at buf[0], returns previous buf[len-1].

mem_multiply_sum(src1,src2,length)

Calculates the sum of the products of values pointed to by src1 and src2. If src2 is -1, then calculates the sum of squares of src1, if -2, the sum of the absolute values of src, if -3, calculates the sum of the values of src1. Other negative values are undefined.

mem_set_values(offset, ...)

Writes values to memory starting at offset from variables specified. Slower than regular memory writes for less than a few variables, faster for more than a few. Undefined behavior if used with more than 32767 variables.

memcpy(dest,src,length)

Copies length items of memory from src to dest. Regions are permitted to overlap.

memset(offset,value,length)

Sets length items of memory at offset to value.

min(&value,&value)

Returns (by reference) the minimum value of the two parameters. Since min() returns by reference, expressions such as min(x,y) = 5 are possible.

printf("format"[, ...])

Output formatted string to system-specific destination, see sprintf() for more information

rand([max])

Returns a pseudorandom real number between 0 and the parameter, inclusive. If the parameter is omitted or less than 1.0, 1.0 is used as a maximum instead.

runloop("code")

Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to defer().
Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.

set_action_options(flags)

Sets action options for the script.
flag&1: script will auto-terminate if re-launched while already running
flag&2: if (flag&1) is set, script will re-launch after auto-terminating
flag&4: set script toggle state on
flag&8: set script toggle state off


sign(value)

Returns 1.0 if the parameter is greater than 0, -1.0 if the parameter is less than 0, or 0 if the parameter is 0.

sin(angle)

Returns the sine of the angle specified (specified in radians -- to convert from degrees to radians, multiply by $pi/180, or 0.017453).

sleep(ms)

Yields the CPU for the millisecond count specified, calling Sleep() on Windows or usleep() on other platforms.

sprintf(#dest,"format"[, ...])

Formats a string and stores it in #dest. Format specifiers begin with %, and may include:

  • %% = %
  • %s = string from parameter
  • %d = parameter as integer
  • %i = parameter as integer
  • %u = parameter as unsigned integer
  • %x = parameter as hex (lowercase) integer
  • %X = parameter as hex (uppercase) integer
  • %c = parameter as character
  • %f = parameter as floating point
  • %e = parameter as floating point (scientific notation, lowercase)
  • %E = parameter as floating point (scientific notation, uppercase)
  • %g = parameter as floating point (shortest representation, lowercase)
  • %G = parameter as floating point (shortest representation, uppercase)

Many standard C printf() modifiers can be used, including:

  • %.10s = string, but only print up to 10 characters
  • %-10s = string, left justified to 10 characters
  • %10s = string, right justified to 10 characters
  • %+f = floating point, always show sign
  • %.4f = floating point, minimum of 4 digits after decimal point
  • %10d = integer, minimum of 10 digits (space padded)
  • %010f = integer, minimum of 10 digits (zero padded)

Values for format specifiers can be specified as additional parameters to sprintf, or within {} in the format specifier (such as %{varname}d, in that case a global variable is always used).

sqr(value)

Returns the square of the parameter (similar to value*value, but only evaluating value once).

sqrt(value)

Returns the square root of the parameter. If the parameter is negative, the return value is undefined.

stack_exch(&value)

Exchanges a value with the top of the stack, and returns a reference to the parameter (with the new value).

stack_peek(index)

Returns a reference to the item on the top of the stack (if index is 0), or to the Nth item on the stack if index is greater than 0.

stack_pop(&value)

Pops a value from the user stack into value, or into a temporary buffer if value is not specified, and returns a reference to where the stack was popped. Note that no checking is done to determine if the stack is empty, and as such stack_pop() will never fail.

stack_push(&value)

Pushes value onto the user stack, returns a reference to the parameter.

str_delsub(#str,pos,len)

Deletes len characters at offset pos from #str, and returns #str.

str_getchar("str",offset[,type])

Returns the data at byte-offset offset of str. If offset is negative, position is relative to end of string.type defaults to signed char, but can be specified to read raw binary data in other formats (note the single quotes, these are single/multi-byte characters):

  • 'c' - signed char
  • 'cu' - unsigned char
  • 's' - signed short
  • 'S' - signed short, big endian
  • 'su' - unsigned short
  • 'Su' - unsigned short, big endian
  • 'i' - signed int
  • 'I' - signed int, big endian
  • 'iu' - unsigned int
  • 'Iu' - unsigned int, big endian
  • 'f' - float
  • 'F' - float, big endian
  • 'd' - double
  • 'D' - double, big endian
str_insert(#str,"srcstr",pos)

Inserts srcstr into #str at offset pos. Returns #str

str_setchar(#str,offset,val[,type]))

Sets value at offset offset, type optional. offset may be negative to refer to offset relative to end of string, or between 0 and length, inclusive, and if set to length it will lengthen string. See str_getchar() for more information on types.

str_setlen(#str,len)

Sets length of #str (if increasing, will be space-padded), and returns #str.

strcat(#str,"srcstr")

Appends srcstr to #str, and returns #str

strcmp("str","str2")

Compares strings, returning 0 if equal

strcpy(#str,"srcstr")

Copies the contents of srcstr to #str, and returns #str

strcpy_from(#str,"srcstr",offset)

Copies srcstr to #str, but starts reading srcstr at offset offset

strcpy_substr(#str,"srcstr",offs,ml))

PHP-style (start at offs, offs<0 means from end, ml for maxlen, ml<0 = reduce length by this amt)

stricmp("str","str2")

Compares strings ignoring case, returning 0 if equal

strlen("str")

Returns the length of the string passed as a parameter

strncat(#str,"srcstr",maxlen)

Appends srcstr to #str, stopping after maxlen characters of srcstr. Returns #str.

strncmp("str","str2",maxlen)

Compares strings giving up after maxlen characters, returning 0 if equal

strncpy(#str,"srcstr",maxlen)

Copies srcstr to #str, stopping after maxlen characters. Returns #str.

strnicmp("str","str2",maxlen)

Compares strings giving up after maxlen characters, ignoring case, returning 0 if equal

tan(angle)

Returns the tangent of the angle specified (specified in radians).

tcp_close(connection)

Closes a TCP connection created by tcp_listen() or tcp_connect().

tcp_connect("address",port[,block])

Create a new TCP connection to address:port. If block is specified and 0, connection will be made nonblocking. Returns TCP connection ID greater than 0 on success.

tcp_listen(port[,"interface",#ip_out])

Listens on port specified. Returns less than 0 if could not listen, 0 if no new connection available, or greater than 0 (as a TCP connection ID) if a new connection was made. If a connection made and #ip_out specified, it will be set to the remote IP. interface can be empty for all interfaces, otherwise an interface IP as a string.

tcp_listen_end(port)

Ends listening on port specified.

tcp_recv(connection,#str[,maxlen])

Receives data from a connection to #str. If maxlen is specified, no more than maxlen bytes will be received. If non-blocking, 0 will be returned if would block. Returns less than 0 if error.

tcp_send(connection,"str"[,len])

Sends a string to connection. Returns -1 on error, 0 if connection is non-blocking and would block, otherwise returns length sent. If len is specified and not less than 1, only the first len bytes of the string parameter will be sent.

tcp_set_block(connection,block)

Sets whether a connection blocks.

time([&val])

Sets the parameter (or a temporary buffer if omitted) to the number of seconds since January 1, 1970, and returns a reference to that value. The granularity of the value returned is 1 second.

time_precise([&val])

Sets the parameter (or a temporary buffer if omitted) to a system-local timestamp in seconds, and returns a reference to that value. The granularity of the value returned is system defined (but generally significantly smaller than one second).

while(expression)

Executes expression until expression evaluates to zero, or until 1048576iterations occur. An alternate and more useful syntax is while (expression) ( statements ), which evaluates statements after every non-zero evaluation of expression.

ReaScript/Lua Built-In Function List

reaper.atexit(function)

Adds code to be executed when the script finishes or is ended by the user. Typically used to clean up after the user terminates defer() or runloop() code.

reaper.defer(function)

Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to runloop().
Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.

reaper.get_action_context()

is_new_value,filename,sectionID,cmdID,mode,resolution,val,contextstr = reaper.get_action_context()
Returns contextual information about the script, typically MIDI/OSC input values.
val will be set to a relative or absolute value depending on mode (=0: absolute mode, >0: relative modes).
resolution=127 for 7-bit resolution, =16383 for 14-bit resolution.
sectionID, and cmdID will be set to -1 if the script is not part of the action list.
mode, resolution and val will be set to -1 if the script was not triggered via MIDI/OSC.
contextstr may be empty or one of:

  • midi:XX[:YY] (one or two bytes hex)
  • [wheel|hwheel|mtvert|mthorz|mtzoom|mtrot|mediakbd]:flags
  • key:flags:keycode
  • osc:/msg[:f=FloatValue|:s=StringValue]
  • KBD_OnMainActionEx

(flags may include V=virtkey, S=shift, A=alt/option, C=control/command, W=win/control)

gfx VARIABLES

The following global variables are special and will be used by the graphics system:

  • gfx.r - current red component (0..1) used by drawing operations.
  • gfx.g - current green component (0..1) used by drawing operations.
  • gfx.b - current blue component (0..1) used by drawing operations.
  • gfx.a2 - current alpha component (0..1) used by drawing operations when writing solid colors (normally ignored but useful when creating transparent images).
  • gfx.a - alpha for drawing (1=normal).
  • gfx.mode - blend mode for drawing. Set mode to 0 for default options. Add 1.0 for additive blend mode (if you wish to do subtractive, set gfx.a to negative and use gfx.mode as additive). Add 2.0 to disable source alpha for gfx.blit(). Add 4.0 to disable filtering for gfx.blit().
  • gfx.w - width of the UI framebuffer.
  • gfx.h - height of the UI framebuffer.
  • gfx.x - current graphics position X. Some drawing functions use as start position and update.
  • gfx.y - current graphics position Y. Some drawing functions use as start position and update.
  • gfx.clear - if greater than -1.0, framebuffer will be cleared to that color. the color for this one is packed RGB (0..255), i.e. red+green*256+blue*65536. The default is 0 (black).
  • gfx.dest - destination for drawing operations, -1 is main framebuffer, set to 0..1024-1 to have drawing operations go to an offscreen buffer (or loaded image).
  • gfx.texth - the (READ-ONLY) height of a line of text in the current font. Do not modify this variable.
  • gfx.ext_retina - to support hidpi/retina, callers should set to 1.0 on initialization, this value will be updated to value greater than 1.0 (such as 2.0) if retina/hidpi. On macOS gfx.w/gfx.h/etc will be doubled, but on other systems gfx.w/gfx.h will remain the same and gfx.ext_retina is a scaling hint for drawing.
  • gfx.mouse_x - current X coordinate of the mouse relative to the graphics window.
  • gfx.mouse_y - current Y coordinate of the mouse relative to the graphics window.
  • gfx.mouse_wheel - wheel position, will change typically by 120 or a multiple thereof, the caller should clear the state to 0 after reading it.
  • gfx.mouse_hwheel - horizontal wheel positions, will change typically by 120 or a multiple thereof, the caller should clear the state to 0 after reading it.
  • gfx.mouse_cap - a bitfield of mouse and keyboard modifier state. Note that a script must call gfx.getchar() at least once in order to get modifier state when the mouse is not captured by the window. Bitfield bits:
    • 1: left mouse button
    • 2: right mouse button
    • 4: Control key
    • 8: Shift key
    • 16: Alt key
    • 32: Windows key
    • 64: middle mouse button
gfx.arc(x,y,r,ang1,ang2[,antialias])

Draws an arc of the circle centered at x,y, with ang1/ang2 being specified in radians.

gfx.blit(source[, scale, rotation, srcx, srcy, srcw, srch, destx, desty, destw, desth, rotxoffs, rotyoffs])

Copies from source (-1 = main framebuffer, or an image from gfx.loadimg() etc), using current opacity and copy mode (set with gfx.a, gfx.mode).
If destx/desty are not specified, gfx.x/gfx.y will be used as the destination position.
scale (1.0 is unscaled) will be used only if destw/desth are not specified.
rotation is an angle in radians
srcx/srcy/srcw/srch specify the source rectangle (if omitted srcw/srch default to image size)
destx/desty/destw/desth specify destination rectangle (if not specified destw/desth default to srcw/srch * scale).

gfx.blitext(source,coordinatelist,rotation)

Deprecated, use gfx.blit instead.

gfx.blurto(x,y)

Blurs the region of the screen between gfx.x,gfx.y and x,y, and updates gfx.x,gfx.y to x,y.

gfx.circle(x,y,r[,fill,antialias])

Draws a circle, optionally filling/antialiasing.

gfx.clienttoscreen(x,y)

Converts the coordinates x,y to screen coordinates, returns those values.

gfx.deltablit(srcimg,srcs,srct,srcw,srch,destx,desty,destw,desth,dsdx,dtdx,dsdy,dtdy,dsdxdy,dtdxdy[,usecliprect=1])

Blits from srcimg(srcx,srcy,srcw,srch) to destination (destx,desty,destw,desth). Source texture coordinates are s/t, dsdx represents the change in s coordinate for each x pixel, dtdy represents the change in t coordinate for each y pixel, etc. dsdxdy represents the change in dsdx for each line. If usecliprect is specified and 0, then srcw/srch are ignored.

gfx.dock(v[,wx,wy,ww,wh])

Call with v=-1 to query docked state, otherwise v>=0 to set docked state. State is &1 if docked, second byte is docker index (or last docker index if undocked). If wx-wh specified, additional values will be returned with the undocked window position/size

gfx.drawchar(char)

Draws the character (can be a numeric ASCII code as well), to gfx.x, gfx.y, and moves gfx.x over by the size of the character.

gfx.drawnumber(n,ndigits)

Draws the number n with ndigits of precision to gfx.x, gfx.y, and updates gfx.x to the right side of the drawing. The text height is gfx.texth.

gfx.drawstr("str"[,flags,right,bottom])

Draws a string at gfx.x, gfx.y, and updates gfx.x/gfx.y so that subsequent draws will occur in a similar place.

If flags, right ,bottom passed in:

  • flags&1: center horizontally
  • flags&2: right justify
  • flags&4: center vertically
  • flags&8: bottom justify
  • flags&256: ignore right/bottom, otherwise text is clipped to (gfx.x, gfx.y, right, bottom)
gfx.getchar([char, unichar])

If char is 0 or omitted, returns a character from the keyboard queue, or 0 if no character is available, or -1 if the graphics window is not open. If char is specified and nonzero, that character's status will be checked, and the function will return greater than 0 if it is pressed. Note that calling gfx.getchar() at least once causes gfx.mouse_cap to reflect keyboard modifiers even when the mouse is not captured.

Common values are standard ASCII, such as 'a', 'A', '=' and '1', but for many keys multi-byte values are used, including 'home', 'up', 'down', 'left', 'rght', 'f1'.. 'f12', 'pgup', 'pgdn', 'ins', and 'del'.

Modified and special keys can also be returned, including:

  • Ctrl/Cmd+A..Ctrl+Z as 1..26
  • Ctrl/Cmd+Alt+A..Z as 257..282
  • Alt+A..Z as 'A'+256..'Z'+256
  • 27 for ESC
  • 13 for Enter
  • ' ' for space
  • 65536 for query of special flags, returns: &1 (supported), &2=window has focus, &4=window is visible, &8=mouse click would hit window. 65537 queries special flags but does not do the mouse click hit testing (faster).
  • If unichar is specified, it will be set to the unicode value of the key if available (and the return value may be the unicode value or a raw key value as described above, depending). If unichar is not specified, unicode codepoints greater than 255 will be returned as 'u'<<24 + value
gfx.getdropfile(idx)

Returns success,string for dropped file index idx. call gfx.dropfile(-1) to clear the list when finished.

gfx.getfont()

Returns current font index, and the actual font face used by this font (if available).

gfx.getimgdim(handle)

Retreives the dimensions of an image specified by handle, returns w, h pair.

gfx.getpixel()

Returns r,g,b values [0..1] of the pixel at (gfx.x,gfx.y)

gfx.gradrect(x,y,w,h, r,g,b,a[, drdx, dgdx, dbdx, dadx, drdy, dgdy, dbdy, dady])

Fills a gradient rectangle with the color and alpha specified. drdx-dadx reflect the adjustment (per-pixel) applied for each pixel moved to the right, drdy-dady are the adjustment applied for each pixel moved toward the bottom. Normally drdx=adjustamount/w, drdy=adjustamount/h, etc.

gfx.init("name"[,width,height,dockstate,xpos,ypos])

Initializes the graphics window with title name. Suggested width and height can be specified. If window is already open, a non-empty name will re-title window, or an empty title will resize window.

Once the graphics window is open, gfx.update() should be called periodically.

gfx.line(x,y,x2,y2[,aa])

Draws a line from x,y to x2,y2, and if aa is not specified or 0.5 or greater, it will be antialiased.

gfx.lineto(x,y[,aa])

Draws a line from gfx.x,gfx.y to x,y. If aa is 0.5 or greater, then antialiasing is used. Updates gfx.x and gfx.y to x,y.

gfx.loadimg(image,"filename")

Load image from filename into slot 0..1024-1 specified by image. Returns the image index if success, otherwise -1 if failure. The image will be resized to the dimensions of the image file.

gfx.measurechar(char)

Measures the drawing dimensions of a character with the current font (as set by gfx.setfont). Returns width and height of character.

gfx.measurestr("str")

Measures the drawing dimensions of a string with the current font (as set by gfx.setfont). Returns width and height of string.

gfx.muladdrect(x,y,w,h,mul_r,mul_g,mul_b[,mul_a,add_r,add_g,add_b,add_a])

Multiplies each pixel by mul_* and adds add_*, and updates in-place. Useful for changing brightness/contrast, or other effects.

gfx.printf("format"[, ...])

Formats and draws a string at gfx.x, gfx.y, and updates gfx.x/gfx.y accordingly (the latter only if the formatted string contains newline). For more information on format strings, see sprintf()

gfx.quit()

Closes the graphics window.

gfx.rect(x,y,w,h[,filled])

Fills a rectangle at x,y, w,h pixels in dimension, filled by default.

gfx.rectto(x,y)

Fills a rectangle from gfx.x,gfx.y to x,y. Updates gfx.x,gfx.y to x,y.

gfx.roundrect(x,y,w,h,radius[,antialias])

Draws a rectangle with rounded corners.

gfx.screentoclient(x,y)

Converts the screen coordinates x,y to client coordinates, returns those values.

gfx.set(r[,g,b,a,mode,dest,a2])

Sets gfx.r/gfx.g/gfx.b/gfx.a/gfx.mode/gfx.a2, sets gfx.dest if final parameter specified

gfx.setcursor(resource_id,custom_cursor_name)

Sets the mouse cursor to resource_id and/or custom_cursor_name.

gfx.setfont(idx[,"fontface", sz, flags])

Can select a font and optionally configure it. idx=0 for default bitmapped font, no configuration is possible for this font. idx=1..16 for a configurable font, specify fontface such as "Arial", sz of 8-100, and optionally specify flags, which is a multibyte character, which can include 'i' for italics, 'u' for underline, or 'b' for bold. These flags may or may not be supported depending on the font and OS. After calling gfx.setfont(), gfx.texth may be updated to reflect the new average line height.

gfx.setimgdim(image,w,h)

Resize image referenced by index 0..1024-1, width and height must be 0-8192. The contents of the image will be undefined after the resize.

gfx.setpixel(r,g,b)

Writes a pixel of r,g,b to gfx.x,gfx.y.

gfx.showmenu("str")

Shows a popup menu at gfx.x,gfx.y. str is a list of fields separated by | characters. Each field represents a menu item.
Fields can start with special characters:

# : grayed out
! : checked
> : this menu item shows a submenu
< : last item in the current submenu

An empty field will appear as a separator in the menu. gfx.showmenu returns 0 if the user selected nothing from the menu, 1 if the first field is selected, etc.
Example:

gfx.showmenu("first item, followed by separator||!second item, checked|>third item which spawns a submenu|#first item in submenu, grayed out|<second and last item in submenu|fourth item in top menu")

gfx.transformblit(srcimg,destx,desty,destw,desth,div_w,div_h,table)

Blits to destination at (destx,desty), size (destw,desth). div_w and div_h should be 2..64, and table should point to a table of 2*div_w*div_h values (table can be a regular table or (for less overhead) a reaper.array). Each pair in the table represents a S,T coordinate in the source image, and the table is treated as a left-right, top-bottom list of texture coordinates, which will then be rendered to the destination.

gfx.triangle(x1,y1,x2,y2,x3,y3[x4,y4...])

Draws a filled triangle, or any convex polygon.

gfx.update()

Updates the graphics display, if opened

reaper.gmem_attach(sharedMemoryName)

Causes gmem_read()/gmem_write() to read EEL2/JSFX/Video shared memory segment named by parameter. Set to empty string to detach. 6.20+: returns previous shared memory segment name.

reaper.gmem_read(index)

Read (number) value from shared memory attached-to by gmem_attach(). index can be [0..1<<25).

reaper.gmem_write(index,value)

Write (number) value to shared memory attached-to by gmem_attach(). index can be [0..1<<25).

reaper.new_array([table|array][size])

Creates a new reaper.array object of maximum and initial size size, if specified, or from the size/values of a table/array. Both size and table/array can be specified, the size parameter will override the table/array size.

reaper.runloop(function)

Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to defer().
Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.

reaper.set_action_options(flag)

reaper.set_action_options(flag)
Sets action options for the script.
flag&1: script will auto-terminate if re-launched while already running
flag&2: if (flag&1) is set, script will re-launch after auto-terminating
flag&4: set script toggle state on
flag&8: set script toggle state off


{reaper.array}.clear([value, offset, size])

Sets the value of zero or more items in the array. If value not specified, 0.0 is used. offset is 1-based, if size omitted then the maximum amount available will be set.

{reaper.array}.convolve([src, srcoffs, size, destoffs])

Convolves complex value pairs from reaper.array, starting at 1-based srcoffs, reading/writing to 1-based destoffs. size is in normal items (so it must be even)

{reaper.array}.copy([src, srcoffs, size, destoffs])

Copies values from reaper.array or table, starting at 1-based srcoffs, writing to 1-based destoffs.

{reaper.array}.fft(size[, permute, offset])

Performs a forward FFT of size. size must be a power of two between 4 and 32768 inclusive. If permute is specified and true, the values will be shuffled following the FFT to be in normal order.

{reaper.array}.fft_real(size[, permute, offset])

Performs a forward real->complex FFT of size. size must be a power of two between 4 and 32768 inclusive. If permute is specified and true, the values will be shuffled following the FFT to be in normal order.

{reaper.array}.get_alloc()

Returns the maximum (allocated) size of the array.

{reaper.array}.ifft(size[, permute, offset])

Performs a backwards FFT of size. size must be a power of two between 4 and 32768 inclusive. If permute is specified and true, the values will be shuffled before the IFFT to be in fft-order.

{reaper.array}.ifft_real(size[, permute, offset])

Performs a backwards complex->real FFT of size. size must be a power of two between 4 and 32768 inclusive. If permute is specified and true, the values will be shuffled before the IFFT to be in fft-order.

{reaper.array}.multiply([src, srcoffs, size, destoffs])

Multiplies values from reaper.array, starting at 1-based srcoffs, reading/writing to 1-based destoffs.

{reaper.array}.resize(size)

Resizes an array object to size. size must be [0..max_size].

{reaper.array}.table([offset, size])

Returns a new table with values from items in the array. Offset is 1-based and if size is omitted all available values are used.

ReaScript/Python Built-In Function List

RPR_atexit(String)

Adds code to be executed when the script finishes or is ended by the user. Typically used to clean up after the user terminates defer() or runloop() code.

RPR_defer(String code)

Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to runloop().
Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.

RPR_runloop(String code)

Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to defer().
Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.