(cache)REAPER API functions

ReaScript/EEL Built-in Function List

EEL: abs(value)

Returns the absolute value of the parameter.

EEL: 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.

EEL: 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.

EEL: 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.

EEL: 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.

EEL: 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.

EEL: ceil(value)

Returns the value rounded to the next highest integer (ceil(3.1)==4, ceil(-3.9)==-3).

EEL: convolve_c(dest,src,size)

Multiplies each of size complex pairs in dest by the complex pairs in src. Often used for convolution.

EEL: cos(angle)

Returns the cosine of the angle specified (specified in radians).

EEL: 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.

EEL: eval("code")

Executes code passed in. Code can use functions, but functions created in code can't be used elsewhere.

EEL: 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.

EEL: 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).

EEL: fclose(fp)

Closes a file previously opened with fopen().

EEL: feof(fp)

Returns nonzero if the file fp is at the end of file.

EEL: fflush(fp)

If file fp is open for writing, flushes out any buffered data to disk.

EEL: 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.

EEL: fft_ipermute(buffer,size)

Permute the input for ifft(), taking bands from in-order to the order ifft() requires. See fft() for more information.

EEL: fft_permute(buffer,size)

Permute the output of fft() to have bands in-order. See fft() for more information.

EEL: 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.

EEL: fgetc(fp)

Reads a character from file fp, returns -1 if EOF.

EEL: fgets(fp,#str)

Reads a line from file fp into #str. Returns length of #str read.

EEL: floor(value)

Returns the value rounded to the next lowest integer (floor(3.9)==3, floor(-3.1)==-4).

EEL: 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.

EEL: 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.

EEL: fread(fp,#str,length)

Reads from file fp into #str, up to length bytes. Returns actual length read, or negative if error.

EEL: 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.

EEL: 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.

EEL: ftell(fp)

Retunrs the current file position.

EEL: 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.

EEL: get_action_context(#filename,sectionID,cmdID,mode,resolution,val)

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.
Notes: 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.

EEL: gfx VARIABLES

The following global variables are special and will be used by the graphics system:

gfx_r, gfx_g, gfx_b, gfx_a - These represent the current red, green, blue, and alpha components used by drawing operations (0.0..1.0).
gfx_w, gfx_h - These are set to the current width and height of the UI framebuffer.
gfx_x, gfx_y - These set the "current" graphics position in x,y. You can set these yourselves, and many of the drawing functions update them as well.
gfx_mode - Set 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_clear - If set to a value greater than -1.0, this will result in the framebuffer being 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 - Defaults to -1, set to 0..1024-1 to have drawing operations go to an offscreen buffer (or loaded image).
gfx_texth - Set to the height of a line of text in the current font. Do not modify this variable.
gfx_ext_retina - If set to 1.0 on initialization, will be updated to 2.0 if high resolution display is supported, and if so gfx_w/gfx_h/etc will be doubled.
mouse_x, mouse_y - mouse_x and mouse_y are set to the coordinates of the mouse relative to the graphics window.
mouse_wheel, mouse_hwheel - mouse wheel (and horizontal wheel) positions. These will change typically by 120 or a multiple thereof, the caller should clear the state to 0 after reading it.
mouse_cap is a bitfield of mouse and keyboard modifier state.
- 1: left mouse button
- 2: right mouse button
- 4: Command key
- 8: Shift key
- 16: Option key
- 32: Control key
- 64: middle mouse button

EEL: 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.

EEL: gfx_blit(source, scale, rotation[, srcx, srcy, srcw, srch, destx, desty, destw, desth, rotxoffs, rotyoffs])

srcx/srcy/srcw/srch specify the source rectangle (if omitted srcw/srch default to image size), destx/desty/destw/desth specify dest rectangle (if not specified, these will default to reasonable defaults -- destw/desth default to srcw/srch * scale).

EEL: gfx_blit(source,scale,rotation)

If three parameters are specified, copies the entirity of the source bitmap to gfx_x,gfx_y using current opacity and copy mode (set with gfx_a, gfx_mode). You can specify scale (1.0 is unscaled) and rotation (0.0 is not rotated, angles are in radians).
For the "source" parameter specify -1 to use the main framebuffer as source, or an image index (see gfx_loadimg()).

EEL: gfx_blitext(source,coordinatelist,rotation)

Deprecated, use gfx_blit instead.

EEL: 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.

EEL: gfx_circle(x,y,r[,fill,antialias])

Draws a circle, optionally filling/antialiasing.

EEL: gfx_clienttoscreen(x,y)

Converts client coordinates x,y to screen coordinates.

EEL: 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.

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

EEL: 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.

EEL: 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.

EEL: 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)

EEL: gfx_getchar([char])

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.

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

EEL: 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.

EEL: 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.

EEL: 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).

EEL: gfx_getpixel(r,g,b)

Gets the value of the pixel at gfx_x,gfx_y into r,g,b.

EEL: 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.

EEL: gfx_init("name"[,width,height,dockstate,xpos,ypos])

Initializes the graphics window with title name. Suggested width and height can be specified.

Once the graphics window is open, gfx_update() should be called periodically.

EEL: 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.

EEL: 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.

EEL: 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.

EEL: gfx_measurechar(character,&w,&h)

Measures the drawing dimensions of a character with the current font (as set by gfx_setfont).

EEL: gfx_measurestr("str",&w,&h)

Measures the drawing dimensions of a string with the current font (as set by gfx_setfont).

EEL: 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.

EEL: 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()

EEL: gfx_quit()

Closes the graphics window.

EEL: gfx_rect(x,y,w,h[,filled])

Fills a rectangle at x,y, w,h pixels in dimension, filled by default.

EEL: gfx_rectto(x,y)

Fills a rectangle from gfx_x,gfx_y to x,y. Updates gfx_x,gfx_y to x,y.

EEL: gfx_roundrect(x,y,w,h,radius[,antialias])

Draws a rectangle with rounded corners.

EEL: gfx_screentoclient(x,y)

Converts screen coordinates x,y to client coordinates.

EEL: gfx_set(r[,g,b,a,mode,dest])

Sets gfx_r/gfx_g/gfx_b/gfx_a/gfx_mode, sets gfx_dest if final parameter specified

EEL: gfx_setcursor(resource_id,custom_cursor_name)

Sets the mouse cursor. resource_id is a value like 32512 (for an arrow cursor), custom_cursor_name is a string like "arrow" (for the REAPER custom arrow cursor). resource_id must be nonzero, but custom_cursor_name is optional.

EEL: 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.

EEL: gfx_setimgdim(image,w,h)

Resize image referenced by index 0..1024-1, width and height must be 0-2048. The contents of the image will be undefined after the resize.

EEL: gfx_setpixel(r,g,b)

Writes a pixel of r,g,b to gfx_x,gfx_y.

EEL: 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")

EEL: 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.

EEL: gfx_triangle(x1,y1,x2,y2,x3,y3[x4,y4...])

Draws a filled triangle, or any convex polygon.

EEL: gfx_update()

Updates the graphics display, if opened

EEL: ifft(buffer,size)

Perform an inverse FFT. For more information see fft().

EEL: 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).

EEL: invsqrt(value)

Returns a fast inverse square root (1/sqrt(x)) approximation of the parameter.

EEL: log(value)

Returns the natural logarithm (base e) of the parameter. If the value is not greater than 0, the return value is undefined.

EEL: log10(value)

Returns the base-10 logarithm of the parameter. If the value is not greater than 0, the return value is undefined.

EEL: loop(count,expression)

Evaluates count once, and then executes expression count, but not more than 1048576, times.

EEL: 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 {}.

EEL: matchi("needle","haystack"[, ...])

Case-insensitive version of match().

EEL: 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.

EEL: 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.

EEL: 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.

EEL: memcpy(dest,src,length)

Copies length items of memory from src to dest. Regions are permitted to overlap.

EEL: memset(offset,value,length)

Sets length items of memory at offset to value.

EEL: 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.

EEL: printf("format"[, ...])

Output formatted string to system-specific destination, see sprintf() for more information

EEL: rand([max])

Returns a psuedorandom 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.

EEL: 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.

EEL: 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.

EEL: 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).

EEL: sleep(ms)

Yields the CPU for the millisecond count specified, calling Sleep() on Windows or usleep() on other platforms.

EEL: 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).

EEL: sqr(value)

Returns the square of the parameter (similar to value*value, but only evaluating value once).

EEL: sqrt(value)

Returns the square root of the parameter. If the parameter is negative, the return value is undefined.

EEL: stack_exch(&value)

Exchanges a value with the top of the stack, and returns a reference to the parameter (with the new value).

EEL: 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.

EEL: 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.

EEL: stack_push(&value)

Pushes value onto the user stack, returns a reference to the parameter.

EEL: str_delsub(#str,pos,len)

Deletes len characters at offset pos from #str, and returns #str.

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

EEL: str_insert(#str,"srcstr",pos)

Inserts srcstr into #str at offset pos. Returns #str

EEL: 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.

EEL: str_setlen(#str,len)

Sets length of #str (if increasing, will be space-padded), and returns #str.

EEL: strcat(#str,"srcstr")

Appends srcstr to #str, and returns #str

EEL: strcmp("str","str2")

Compares strings, returning 0 if equal

EEL: strcpy(#str,"srcstr")

Copies the contents of srcstr to #str, and returns #str

EEL: strcpy_from(#str,"srcstr",offset)

Copies srcstr to #str, but starts reading srcstr at offset offset

EEL: 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)

EEL: stricmp("str","str2")

Compares strings ignoring case, returning 0 if equal

EEL: strlen("str")

Returns the length of the string passed as a parameter

EEL: strncat(#str,"srcstr",maxlen)

Appends srcstr to #str, stopping after maxlen characters of srcstr. Returns #str.

EEL: strncmp("str","str2",maxlen)

Compares strings giving up after maxlen characters, returning 0 if equal

EEL: strncpy(#str,"srcstr",maxlen)

Copies srcstr to #str, stopping after maxlen characters. Returns #str.

EEL: strnicmp("str","str2",maxlen)

Compares strings giving up after maxlen characters, ignoring case, returning 0 if equal

EEL: tan(angle)

Returns the tangent of the angle specified (specified in radians).

EEL: tcp_close(connection)

Closes a TCP connection created by tcp_listen() or tcp_connect().

EEL: 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.

EEL: 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.

EEL: tcp_listen_end(port)

Ends listening on port specified.

EEL: 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.

EEL: 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.

EEL: tcp_set_block(connection,block)

Sets whether a connection blocks.

EEL: 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.

EEL: 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).

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

Lua: 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.

Lua: 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.

Lua: reaper.get_action_context()

is_new_value,filename,sectionID,cmdID,mode,resolution,val = 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.
Notes: 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.

Lua: gfx VARIABLES

The following global variables are special and will be used by the graphics system:

gfx.r, gfx.g, gfx.b, gfx.a - These represent the current red, green, blue, and alpha components used by drawing operations (0.0..1.0).
gfx.w, gfx.h - These are set to the current width and height of the UI framebuffer.
gfx.x, gfx.y - These set the "current" graphics position in x,y. You can set these yourselves, and many of the drawing functions update them as well.
gfx.mode - Set 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.clear - If set to a value greater than -1.0, this will result in the framebuffer being 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 - Defaults to -1, set to 0..1024-1 to have drawing operations go to an offscreen buffer (or loaded image).
gfx.texth - Set to the height of a line of text in the current font. Do not modify this variable.
gfx.ext_retina - If set to 1.0 on initialization, will be updated to 2.0 if high resolution display is supported, and if so gfx.w/gfx.h/etc will be doubled.
gfx.mouse_x, gfx.mouse_y - gfx.mouse_x and gfx.mouse_y are set to the coordinates of the mouse relative to the graphics window.
gfx.mouse_wheel, gfx.mouse_hwheel - mouse wheel (and horizontal wheel) positions. These will change typically by 120 or a multiple thereof, the caller should clear the state to 0 after reading it.
gfx.mouse_cap is a bitfield of mouse and keyboard modifier state.
- 1: left mouse button
- 2: right mouse button
- 4: Command key
- 8: Shift key
- 16: Option key
- 32: Control key
- 64: middle mouse button

Lua: 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.

Lua: gfx.blit(source, scale, rotation[, srcx, srcy, srcw, srch, destx, desty, destw, desth, rotxoffs, rotyoffs])

srcx/srcy/srcw/srch specify the source rectangle (if omitted srcw/srch default to image size), destx/desty/destw/desth specify dest rectangle (if not specified, these will default to reasonable defaults -- destw/desth default to srcw/srch * scale).

Lua: gfx.blit(source,scale,rotation)

If three parameters are specified, copies the entirity of the source bitmap to gfx.x,gfx.y using current opacity and copy mode (set with gfx.a, gfx.mode). You can specify scale (1.0 is unscaled) and rotation (0.0 is not rotated, angles are in radians).
For the "source" parameter specify -1 to use the main framebuffer as source, or an image index (see gfx.loadimg()).

Lua: gfx.blitext(source,coordinatelist,rotation)

Deprecated, use gfx.blit instead.

Lua: 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.

Lua: gfx.circle(x,y,r[,fill,antialias])

Draws a circle, optionally filling/antialiasing.

Lua: gfx.clienttoscreen(x,y)

Converts the coordinates x,y to screen coordinates, returns those values.

Lua: 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.

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

Lua: 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.

Lua: 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.

Lua: 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)

Lua: gfx.getchar([char])

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.

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

Lua: gfx.getdropfile(idx)

Returns success,string for dropped file index idx. call gfx.dropfile(-1) to clear the list when finished.

Lua: gfx.getfont()

Returns current font index, and the actual font face used by this font (if available).

Lua: gfx.getimgdim(handle)

Retreives the dimensions of an image specified by handle, returns w, h pair.

Lua: gfx.getpixel()

Returns r,g,b values [0..1] of the pixel at (gfx.x,gfx.y)

Lua: 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.

Lua: gfx.init("name"[,width,height,dockstate,xpos,ypos])

Initializes the graphics window with title name. Suggested width and height can be specified.

Once the graphics window is open, gfx.update() should be called periodically.

Lua: 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.

Lua: 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.

Lua: 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.

Lua: 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.

Lua: 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.

Lua: 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.

Lua: 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()

Lua: gfx.quit()

Closes the graphics window.

Lua: gfx.rect(x,y,w,h[,filled])

Fills a rectangle at x,y, w,h pixels in dimension, filled by default.

Lua: gfx.rectto(x,y)

Fills a rectangle from gfx.x,gfx.y to x,y. Updates gfx.x,gfx.y to x,y.

Lua: gfx.roundrect(x,y,w,h,radius[,antialias])

Draws a rectangle with rounded corners.

Lua: gfx.screentoclient(x,y)

Converts the screen coordinates x,y to client coordinates, returns those values.

Lua: gfx.set(r[,g,b,a,mode,dest])

Sets gfx.r/gfx.g/gfx.b/gfx.a/gfx.mode, sets gfx.dest if final parameter specified

Lua: gfx.setcursor(resource_id,custom_cursor_name)

Sets the mouse cursor. resource_id is a value like 32512 (for an arrow cursor), custom_cursor_name is a string like "arrow" (for the REAPER custom arrow cursor). resource_id must be nonzero, but custom_cursor_name is optional.

Lua: 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.

Lua: gfx.setimgdim(image,w,h)

Resize image referenced by index 0..1024-1, width and height must be 0-2048. The contents of the image will be undefined after the resize.

Lua: gfx.setpixel(r,g,b)

Writes a pixel of r,g,b to gfx.x,gfx.y.

Lua: 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")

Lua: 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.

Lua: gfx.triangle(x1,y1,x2,y2,x3,y3[x4,y4...])

Draws a filled triangle, or any convex polygon.

Lua: gfx.update()

Updates the graphics display, if opened

Lua: 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.

Lua: 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.

Lua: {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.

Lua: {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)

Lua: {reaper.array}.copy([src, srcoffs, size, destoffs])

Copies values from reaper.array or table, starting at 1-based srcoffs, writing to 1-based destoffs.

Lua: {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.

Lua: {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.

Lua: {reaper.array}.get_alloc()

Returns the maximum (allocated) size of the array.

Lua: {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.

Lua: {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.

Lua: {reaper.array}.multiply([src, srcoffs, size, destoffs])

Multiplies values from reaper.array, starting at 1-based srcoffs, reading/writing to 1-based destoffs.

Lua: {reaper.array}.resize(size)

Resizes an array object to size. size must be [0..max_size].

Lua: {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.

AddMediaItemToTrack	GetEnvelopePoint	image_resolve_fn	SetProjExtState
AddProjectMarker	GetEnvelopePointByTime	InsertAutomationItem	SetRegionRenderMatrix
AddProjectMarker2	GetEnvelopePointByTimeEx	InsertEnvelopePoint	SetTakeStretchMarker
AddRemoveReaScript	GetEnvelopePointEx	InsertEnvelopePointEx	SetTakeStretchMarkerSlope
AddTakeToMediaItem	GetEnvelopeScalingMode	InsertMedia	SetTempoTimeSigMarker
AddTempoTimeSigMarker	GetEnvelopeStateChunk	InsertMediaSection	SetToggleCommandState
adjustZoom	GetExePath	InsertTrackAtIndex	SetTrackAutomationMode
AnyTrackSolo	GetExtState	IsMediaExtension	SetTrackColor
APIExists	GetFocusedFX	IsMediaItemSelected	SetTrackMIDILyrics
APITest	GetFreeDiskSpaceForRecordPath	IsProjectDirty	SetTrackMIDINoteName
ApplyNudge	GetFXEnvelope	IsTrackSelected	SetTrackMIDINoteNameEx
ArmCommand	GetGlobalAutomationOverride	IsTrackVisible	SetTrackSelected
Audio_Init	GetHZoomLevel	joystick_create	SetTrackSendInfo_Value
Audio_IsPreBuffer	GetInputChannelName	joystick_destroy	SetTrackSendUIPan
Audio_IsRunning	GetInputOutputLatency	joystick_enum	SetTrackSendUIVol
Audio_Quit	GetItemEditingTime2	joystick_getaxis	SetTrackStateChunk
AudioAccessorValidateState	GetItemProjectContext	joystick_getbuttonmask	ShowActionList
BypassFxAllTracks	GetItemStateChunk	joystick_getinfo	ShowConsoleMsg
ClearAllRecArmed	GetLastColorThemeFile	joystick_getpov	ShowMessageBox
ClearConsole	GetLastMarkerAndCurRegion	joystick_update	ShowPopupMenu
ClearPeakCache	GetLastTouchedFX	LICE_ClipLine	SLIDER2DB
ColorFromNative	GetLastTouchedTrack	Loop_OnArrow	SnapToGrid
ColorToNative	GetMainHwnd	Main_OnCommand	SoloAllTracks
CountAutomationItems	GetMasterMuteSoloFlags	Main_OnCommandEx	Splash_GetWnd
CountEnvelopePoints	GetMasterTrack	Main_openProject	SplitMediaItem
CountEnvelopePointsEx	GetMasterTrackVisibility	Main_SaveProject	stringToGuid
CountMediaItems	GetMaxMidiInputs	Main_UpdateLoopInfo	StuffMIDIMessage
CountProjectMarkers	GetMaxMidiOutputs	MarkProjectDirty	TakeFX_AddByName
CountSelectedMediaItems	GetMediaItem	MarkTrackItemsDirty	TakeFX_CopyToTake
CountSelectedTracks	GetMediaItem_Track	Master_GetPlayRate	TakeFX_CopyToTrack
CountSelectedTracks2	GetMediaItemInfo_Value	Master_GetPlayRateAtTime	TakeFX_Delete
CountTakeEnvelopes	GetMediaItemNumTakes	Master_GetTempo	TakeFX_EndParamEdit
CountTakes	GetMediaItemTake	Master_NormalizePlayRate	TakeFX_FormatParamValue
CountTCPFXParms	GetMediaItemTake_Item	Master_NormalizeTempo	TakeFX_FormatParamValueNormalized
CountTempoTimeSigMarkers	GetMediaItemTake_Peaks	MB	TakeFX_GetChainVisible
CountTrackEnvelopes	GetMediaItemTake_Source	MediaItemDescendsFromTrack	TakeFX_GetCount
CountTrackMediaItems	GetMediaItemTake_Track	MIDI_CountEvts	TakeFX_GetEnabled
CountTracks	GetMediaItemTakeByGUID	MIDI_DeleteCC	TakeFX_GetEnvelope
CreateNewMIDIItemInProj	GetMediaItemTakeInfo_Value	MIDI_DeleteEvt	TakeFX_GetFloatingWindow
CreateTakeAudioAccessor	GetMediaItemTrack	MIDI_DeleteNote	TakeFX_GetFormattedParamValue
CreateTrackAudioAccessor	GetMediaSourceFileName	MIDI_DeleteTextSysexEvt	TakeFX_GetFXGUID
CreateTrackSend	GetMediaSourceLength	MIDI_EnumSelCC	TakeFX_GetFXName
CSurf_FlushUndo	GetMediaSourceNumChannels	MIDI_EnumSelEvts	TakeFX_GetIOSize
CSurf_GetTouchState	GetMediaSourceParent	MIDI_EnumSelNotes	TakeFX_GetNamedConfigParm
CSurf_GoEnd	GetMediaSourceSampleRate	MIDI_EnumSelTextSysexEvts	TakeFX_GetNumParams
CSurf_GoStart	GetMediaSourceType	MIDI_GetAllEvts	TakeFX_GetOffline
CSurf_NumTracks	GetMediaTrackInfo_Value	MIDI_GetCC	TakeFX_GetOpen
CSurf_OnArrow	GetMIDIInputName	MIDI_GetEvt	TakeFX_GetParam
CSurf_OnFwd	GetMIDIOutputName	MIDI_GetGrid	TakeFX_GetParameterStepSizes
CSurf_OnFXChange	GetMixerScroll	MIDI_GetHash	TakeFX_GetParamEx
CSurf_OnInputMonitorChange	GetMouseModifier	MIDI_GetNote	TakeFX_GetParamName
CSurf_OnInputMonitorChangeEx	GetMousePosition	MIDI_GetPPQPos_EndOfMeasure	TakeFX_GetParamNormalized
CSurf_OnMuteChange	GetNumAudioInputs	MIDI_GetPPQPos_StartOfMeasure	TakeFX_GetPinMappings
CSurf_OnMuteChangeEx	GetNumAudioOutputs	MIDI_GetPPQPosFromProjQN	TakeFX_GetPreset
CSurf_OnPanChange	GetNumMIDIInputs	MIDI_GetPPQPosFromProjTime	TakeFX_GetPresetIndex
CSurf_OnPanChangeEx	GetNumMIDIOutputs	MIDI_GetProjQNFromPPQPos	TakeFX_GetUserPresetFilename
CSurf_OnPause	GetNumTracks	MIDI_GetProjTimeFromPPQPos	TakeFX_NavigatePresets
CSurf_OnPlay	GetOS	MIDI_GetScale	TakeFX_SetEnabled
CSurf_OnPlayRateChange	GetOutputChannelName	MIDI_GetTextSysexEvt	TakeFX_SetNamedConfigParm
CSurf_OnRecArmChange	GetOutputLatency	MIDI_GetTrackHash	TakeFX_SetOffline
CSurf_OnRecArmChangeEx	GetParentTrack	MIDI_InsertCC	TakeFX_SetOpen
CSurf_OnRecord	GetPeakFileName	MIDI_InsertEvt	TakeFX_SetParam
CSurf_OnRecvPanChange	GetPeakFileNameEx	MIDI_InsertNote	TakeFX_SetParamNormalized
CSurf_OnRecvVolumeChange	GetPeakFileNameEx2	MIDI_InsertTextSysexEvt	TakeFX_SetPinMappings
CSurf_OnRew	GetPlayPosition	midi_reinit	TakeFX_SetPreset
CSurf_OnRewFwd	GetPlayPosition2	MIDI_SelectAll	TakeFX_SetPresetByIndex
CSurf_OnScroll	GetPlayPosition2Ex	MIDI_SetAllEvts	TakeFX_Show
CSurf_OnSelectedChange	GetPlayPositionEx	MIDI_SetCC	TakeIsMIDI
CSurf_OnSendPanChange	GetPlayState	MIDI_SetEvt	time_precise
CSurf_OnSendVolumeChange	GetPlayStateEx	MIDI_SetItemExtents	TimeMap2_beatsToTime
CSurf_OnSoloChange	GetProjectLength	MIDI_SetNote	TimeMap2_GetDividedBpmAtTime
CSurf_OnSoloChangeEx	GetProjectName	MIDI_SetTextSysexEvt	TimeMap2_GetNextChangeTime
CSurf_OnStop	GetProjectPath	MIDI_Sort	TimeMap2_QNToTime
CSurf_OnTempoChange	GetProjectPathEx	MIDIEditor_GetActive	TimeMap2_timeToBeats
CSurf_OnTrackSelection	GetProjectStateChangeCount	MIDIEditor_GetMode	TimeMap2_timeToQN
CSurf_OnVolumeChange	GetProjectTimeOffset	MIDIEditor_GetSetting_int	TimeMap_curFrameRate
CSurf_OnVolumeChangeEx	GetProjectTimeSignature	MIDIEditor_GetSetting_str	TimeMap_GetDividedBpmAtTime
CSurf_OnWidthChange	GetProjectTimeSignature2	MIDIEditor_GetTake	TimeMap_GetMeasureInfo
CSurf_OnWidthChangeEx	GetProjExtState	MIDIEditor_LastFocused_OnCommand	TimeMap_GetMetronomePattern
CSurf_OnZoom	GetResourcePath	MIDIEditor_OnCommand	TimeMap_GetTimeSigAtTime
CSurf_ResetAllCachedVolPanStates	GetSelectedEnvelope	mkpanstr	TimeMap_QNToMeasures
CSurf_ScrubAmt	GetSelectedMediaItem	mkvolpanstr	TimeMap_QNToTime
CSurf_SetAutoMode	GetSelectedTrack	mkvolstr	TimeMap_QNToTime_abs
CSurf_SetPlayState	GetSelectedTrack2	MoveEditCursor	TimeMap_timeToQN
CSurf_SetRepeatState	GetSelectedTrackEnvelope	MoveMediaItemToTrack	TimeMap_timeToQN_abs
CSurf_SetSurfaceMute	GetSet_ArrangeView2	MuteAllTracks	ToggleTrackSendUIMute
CSurf_SetSurfacePan	GetSet_LoopTimeRange	my_getViewport	Track_GetPeakHoldDB
CSurf_SetSurfaceRecArm	GetSet_LoopTimeRange2	NamedCommandLookup	Track_GetPeakInfo
CSurf_SetSurfaceSelected	GetSetAutomationItemInfo	OnPauseButton	TrackCtl_SetToolTip
CSurf_SetSurfaceSolo	GetSetEnvelopeState	OnPauseButtonEx	TrackFX_AddByName
CSurf_SetSurfaceVolume	GetSetEnvelopeState2	OnPlayButton	TrackFX_CopyToTake
CSurf_SetTrackListChange	GetSetItemState	OnPlayButtonEx	TrackFX_CopyToTrack
CSurf_TrackFromID	GetSetItemState2	OnStopButton	TrackFX_Delete
CSurf_TrackToID	GetSetMediaItemInfo_String	OnStopButtonEx	TrackFX_EndParamEdit
DB2SLIDER	GetSetMediaItemTakeInfo_String	OpenColorThemeFile	TrackFX_FormatParamValue
DeleteEnvelopePointRange	GetSetMediaTrackInfo_String	OpenMediaExplorer	TrackFX_FormatParamValueNormalized
DeleteEnvelopePointRangeEx	GetSetProjectAuthor	OscLocalMessageToHost	TrackFX_GetByName
DeleteExtState	GetSetProjectGrid	parse_timestr	TrackFX_GetChainVisible
DeleteProjectMarker	GetSetProjectNotes	parse_timestr_len	TrackFX_GetCount
DeleteProjectMarkerByIndex	GetSetRepeat	parse_timestr_pos	TrackFX_GetEnabled
DeleteTakeStretchMarkers	GetSetRepeatEx	parsepanstr	TrackFX_GetEQ
DeleteTempoTimeSigMarker	GetSetTrackGroupMembership	PCM_Sink_Enum	TrackFX_GetEQBandEnabled
DeleteTrack	GetSetTrackGroupMembershipHigh	PCM_Sink_GetExtension	TrackFX_GetEQParam
DeleteTrackMediaItem	GetSetTrackState	PCM_Sink_ShowConfig	TrackFX_GetFloatingWindow
DestroyAudioAccessor	GetSetTrackState2	PCM_Source_CreateFromFile	TrackFX_GetFormattedParamValue
Dock_UpdateDockID	GetSubProjectFromSource	PCM_Source_CreateFromFileEx	TrackFX_GetFXGUID
DockIsChildOfDock	GetTake	PCM_Source_CreateFromType	TrackFX_GetFXName
DockWindowActivate	GetTakeEnvelope	PCM_Source_Destroy	TrackFX_GetInstrument
DockWindowAdd	GetTakeEnvelopeByName	PCM_Source_GetPeaks	TrackFX_GetIOSize
DockWindowAddEx	GetTakeName	PCM_Source_GetSectionInfo	TrackFX_GetNamedConfigParm
DockWindowRefresh	GetTakeNumStretchMarkers	PluginWantsAlwaysRunFx	TrackFX_GetNumParams
DockWindowRefreshForHWND	GetTakeStretchMarker	PreventUIRefresh	TrackFX_GetOffline
DockWindowRemove	GetTakeStretchMarkerSlope	ReaScriptError	TrackFX_GetOpen
EditTempoTimeSigMarker	GetTCPFXParm	RecursiveCreateDirectory	TrackFX_GetParam
EnsureNotCompletelyOffscreen	GetTempoMatchPlayRate	RefreshToolbar	TrackFX_GetParameterStepSizes
EnumerateFiles	GetTempoTimeSigMarker	RefreshToolbar2	TrackFX_GetParamEx
EnumerateSubdirectories	GetToggleCommandState	relative_fn	TrackFX_GetParamName
EnumPitchShiftModes	GetToggleCommandStateEx	RemoveTrackSend	TrackFX_GetParamNormalized
EnumPitchShiftSubModes	GetTooltipWindow	RenderFileSection	TrackFX_GetPinMappings
EnumProjectMarkers	GetTrack	ReorderSelectedTracks	TrackFX_GetPreset
EnumProjectMarkers2	GetTrackAutomationMode	Resample_EnumModes	TrackFX_GetPresetIndex
EnumProjectMarkers3	GetTrackColor	resolve_fn	TrackFX_GetRecChainVisible
EnumProjects	GetTrackDepth	resolve_fn2	TrackFX_GetRecCount
EnumProjExtState	GetTrackEnvelope	ReverseNamedCommandLookup	TrackFX_GetUserPresetFilename
EnumRegionRenderMatrix	GetTrackEnvelopeByChunkName	ScaleFromEnvelopeMode	TrackFX_NavigatePresets
EnumTrackMIDIProgramNames	GetTrackEnvelopeByName	ScaleToEnvelopeMode	TrackFX_SetEnabled
EnumTrackMIDIProgramNamesEx	GetTrackGUID	SelectAllMediaItems	TrackFX_SetEQBandEnabled
Envelope_Evaluate	GetTrackMediaItem	SelectProjectInstance	TrackFX_SetEQParam
Envelope_FormatValue	GetTrackMIDILyrics	SetActiveTake	TrackFX_SetNamedConfigParm
Envelope_GetParentTake	GetTrackMIDINoteName	SetAutomationMode	TrackFX_SetOffline
Envelope_GetParentTrack	GetTrackMIDINoteNameEx	SetCurrentBPM	TrackFX_SetOpen
Envelope_SortPoints	GetTrackMIDINoteRange	SetCursorContext	TrackFX_SetParam
Envelope_SortPointsEx	GetTrackName	SetEditCurPos	TrackFX_SetParamNormalized
ExecProcess	GetTrackNumMediaItems	SetEditCurPos2	TrackFX_SetPinMappings
file_exists	GetTrackNumSends	SetEnvelopePoint	TrackFX_SetPreset
FindTempoTimeSigMarker	GetTrackReceiveName	SetEnvelopePointEx	TrackFX_SetPresetByIndex
format_timestr	GetTrackReceiveUIMute	SetEnvelopeStateChunk	TrackFX_Show
format_timestr_len	GetTrackReceiveUIVolPan	SetExtState	TrackList_AdjustWindows
format_timestr_pos	GetTrackSendInfo_Value	SetGlobalAutomationOverride	TrackList_UpdateAllExternalSurfaces
genGuid	GetTrackSendName	SetItemStateChunk	Undo_BeginBlock
get_ini_file	GetTrackSendUIMute	SetMasterTrackVisibility	Undo_BeginBlock2
GetActiveTake	GetTrackSendUIVolPan	SetMediaItemInfo_Value	Undo_CanRedo2
GetAllProjectPlayStates	GetTrackState	SetMediaItemLength	Undo_CanUndo2
GetAppVersion	GetTrackStateChunk	SetMediaItemPosition	Undo_DoRedo2
GetArmedCommand	GetTrackUIMute	SetMediaItemSelected	Undo_DoUndo2
GetAudioAccessorEndTime	GetTrackUIPan	SetMediaItemTake_Source	Undo_EndBlock
GetAudioAccessorHash	GetTrackUIVolPan	SetMediaItemTakeInfo_Value	Undo_EndBlock2
GetAudioAccessorSamples	GetUnderrunTime	SetMediaTrackInfo_Value	Undo_OnStateChange
GetAudioAccessorStartTime	GetUserFileNameForRead	SetMIDIEditorGrid	Undo_OnStateChange2
GetAudioDeviceInfo	GetUserInputs	SetMixerScroll	Undo_OnStateChange_Item
GetConfigWantsDock	GoToMarker	SetMouseModifier	Undo_OnStateChangeEx
GetCurrentProjectInLoadSave	GoToRegion	SetOnlyTrackSelected	Undo_OnStateChangeEx2
GetCursorContext	GR_SelectColor	SetProjectGrid	UpdateArrange
GetCursorContext2	GSC_mainwnd	SetProjectMarker	UpdateItemInProject
GetCursorPosition	guidToString	SetProjectMarker2	UpdateTimeline
GetCursorPositionEx	HasExtState	SetProjectMarker3	ValidatePtr
GetDisplayedMediaItemColor	HasTrackMIDIPrograms	SetProjectMarker4	ValidatePtr2
GetDisplayedMediaItemColor2	HasTrackMIDIProgramsEx	SetProjectMarkerByIndex	ViewPrefs
GetEnvelopeName	Help_Set	SetProjectMarkerByIndex2

ReaScript API

ReaScript/EEL API

ReaScript/Lua API

ReaScript/Python API

API Function List

ReaScript/EEL Built-in Function List

ReaScript/Lua Built-In Function list

ReaScript/Python Built-In Function list

abs	fgets	gfx_drawnumber	gfx_set	memset	strcmp
acos	floor	gfx_drawstr	gfx_setcursor	min	strcpy
asin	fopen	gfx_getchar	gfx_setfont	printf	strcpy_from
atan	fprintf	gfx_getdropfile	gfx_setimgdim	rand	strcpy_substr
atan2	fread	gfx_getfont	gfx_setpixel	runloop	stricmp
atexit	freembuf	gfx_getimgdim	gfx_showmenu	sign	strlen
ceil	fseek	gfx_getpixel	gfx_transformblit	sin	strncat
convolve_c	ftell	gfx_gradrect	gfx_triangle	sleep	strncmp
cos	fwrite	gfx_init	gfx_update	sprintf	strncpy
defer	get_action_context	gfx_line	ifft	sqr	strnicmp
eval	gfx VARIABLES	gfx_lineto	ifft_real	sqrt	tan
exp	gfx_arc	gfx_loadimg	invsqrt	stack_exch	tcp_close
extension_api	gfx_blit	gfx_measurechar	log	stack_peek	tcp_connect
fclose	gfx_blit	gfx_measurestr	log10	stack_pop	tcp_listen
feof	gfx_blitext	gfx_muladdrect	loop	stack_push	tcp_listen_end
fflush	gfx_blurto	gfx_printf	match	str_delsub	tcp_recv
fft	gfx_circle	gfx_quit	matchi	str_getchar	tcp_send
fft_ipermute	gfx_clienttoscreen	gfx_rect	max	str_insert	tcp_set_block
fft_permute	gfx_deltablit	gfx_rectto	mem_get_values	str_setchar	time
fft_real	gfx_dock	gfx_roundrect	mem_set_values	str_setlen	time_precise
fgetc	gfx_drawchar	gfx_screentoclient	memcpy	strcat	while

atexit	gfx.clienttoscreen	gfx.getpixel	gfx.quit	gfx.showmenu	{reaper.array}.fft_real
defer	gfx.deltablit	gfx.gradrect	gfx.rect	gfx.transformblit	{reaper.array}.get_alloc
get_action_context	gfx.dock	gfx.init	gfx.rectto	gfx.triangle	{reaper.array}.ifft
gfx VARIABLES	gfx.drawchar	gfx.line	gfx.roundrect	gfx.update	{reaper.array}.ifft_real
gfx.arc	gfx.drawnumber	gfx.lineto	gfx.screentoclient	new_array	{reaper.array}.multiply
gfx.blit	gfx.drawstr	gfx.loadimg	gfx.set	runloop	{reaper.array}.resize
gfx.blit	gfx.getchar	gfx.measurechar	gfx.setcursor	{reaper.array}.clear	{reaper.array}.table
gfx.blitext	gfx.getdropfile	gfx.measurestr	gfx.setfont	{reaper.array}.convolve
gfx.blurto	gfx.getfont	gfx.muladdrect	gfx.setimgdim	{reaper.array}.copy
gfx.circle	gfx.getimgdim	gfx.printf	gfx.setpixel	{reaper.array}.fft