Enum reaper_medium::RegistrationObject

pub enum RegistrationObject<'a> {
    HookCommand(HookCommandFn),
    HookPostCommand(HookPostCommandFn),
    ToggleAction(ToggleActionFn),
    CommandId(Cow<'a, CStr>),
    Gaccel(NonNull<gaccel_register_t>),
    CsurfInst(NonNull<IReaperControlSurface>),
    Custom(Cow<'a, CStr>, *mut c_void),
}

A thing that you can register at REAPER.

Variants

HookCommand(HookCommandFn)

A hook command.

Extract from reaper_plugin_functions.h:

another thing you can register is "hookcommand", which you pass a callback:
 NON_API: bool runCommand(int command, int flag);
          register("hookcommand",runCommand);
which returns TRUE to eat (process) the command.
flag is usually 0 but can sometimes have useful info depending on the message.
note: it's OK to call Main_OnCommand() within your runCommand, however you MUST check for
recursion if doing so! > in fact, any use of this hook should benefit from a simple
reentrancy test...

HookPostCommand(HookPostCommandFn)

A hook post command.

Extract from reaper_plugin_functions.h:

to get notified when an action of the main section is performed,
you can register "hookpostcommand", which you pass a callback:
 NON_API: void postCommand(int command, int flag);
          register("hookpostcommand",postCommand);

ToggleAction(ToggleActionFn)

A toggle action.

Extract from reaper_plugin.h:

register("toggleaction", toggleactioncallback) lets you register a callback function
that is called to check if an action registered by an extension has an on/off state.

callback function:
  int toggleactioncallback(int command_id);

return:
  -1=action does not belong to this extension, or does not toggle
  0=action belongs to this extension and is currently set to "off"
  1=action belongs to this extension and is currently set to "on"

CommandId(Cow<'a, CStr>)

A command ID for the given command name.

Extract from reaper_plugin_functions.h:

you can also register command IDs for actions,
register with "command_id", parameter is a unique string with only A-Z, 0-9,
returns command ID (or 0 if not supported/out of actions)

Gaccel(NonNull<gaccel_register_t>)

An action description and shortcut.

Extract from reaper_plugin.h:

gaccel_register_t allows you to register ("gaccel") an action into the main keyboard
section action list, and at the same time a default binding for it (accel.cmd is the
command ID, desc is the description, and accel's other parameters are the key to bind.

CsurfInst(NonNull<IReaperControlSurface>)

A hidden control surface (useful for being notified by REAPER about events).

Extract from reaper_plugin.h:

note you can also add a control surface behind the scenes with "csurf_inst"
(IReaperControlSurface*)instance

Custom(Cow<'a, CStr>, *mut c_void)

If a variant is missing in this enum, you can use this custom one as a resort.

Use custom() to create this variant.

Implementations

impl<'a> RegistrationObject<'a>

pub fn custom(
    key: impl Into<ReaperStringArg<'a>>,
    info_struct: *mut c_void
) -> RegistrationObject<'a>

Convenience function for creating a Custom registration object.

Trait Implementations

impl<'a> Clone for RegistrationObject<'a>

fn clone(&self) -> RegistrationObject<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RegistrationObject<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for RegistrationObject<'a>

impl<'a> Hash for RegistrationObject<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<'a> PartialEq<RegistrationObject<'a>> for RegistrationObject<'a>

fn eq(&self, other: &RegistrationObject<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &RegistrationObject<'a>) -> bool

This method tests for !=.

impl<'a> StructuralEq for RegistrationObject<'a>

impl<'a> StructuralPartialEq for RegistrationObject<'a>