Plugins
A plugin is a separate program that works with Input.Observer. Most draw things: the Styles plugin, which comes with Input.Observer, draws the animated trail styles and the decorated hints and messages. Others can add functions that scripts call, or run actions written in another language. Input.Observer starts, watches and stops every plugin itself; you never start a plugin by hand.
This page covers managing plugins. Writing one is described in the separate plugin developer documentation.
Advanced mode. The Plugins page is in the Engine section of the navigation, which is hidden in Simple mode. Plugins keep running in Simple mode, and the Appearance page shows and controls the renderer's styles in either mode.
Changes on this page take effect at once. They are not part of your configuration's unsaved changes: Apply isn't needed, and Discard doesn't undo them. Plugins are never exported or imported.
The Plugins page
| Name | Path | Capabilities | Status | Actions |
|---|---|---|---|---|
| Input.Observer.Styles | C:\Program Files\Input.Observer\Input.Observer.Styles.exe | Styles | Healthy | Disable |
| Sample Plugin | D:\Tools\SamplePlugin.exe | Script functions | Not in use | Use as renderer |
The page lists every registered plugin ②, with a search box and a status filter (All statuses, Healthy, Needs attention, Disabled) above the list. The title line counts the registered and the healthy plugins.
| Column | What it shows |
|---|---|
| Name | The plugin's name. The renderer's row has a Renderer badge. The copy button copies the name exactly, which is what a script's PluginSendMessage call needs. |
| Path | The plugin's program file. The button at its end opens File Explorer with the file selected. |
| Capabilities | What the plugin offers: Gesture trail, Hint, Display message, Styles, Script commands, Script functions, Script engine, Settings, Settings here. A plugin that isn't running shows what it offered when it last ran. |
| Status | See the table below. |
| Actions | The buttons that apply to this plugin right now (below). |
| Status | Meaning |
|---|---|
| Healthy | Running and answering. |
| Starting… | Being started. The page checks again every second until it settles. |
| Not in use | A drawing plugin that isn't the renderer, or the renderer while nothing is set to it. It isn't running, and uses no memory ("Not in use" below). |
| Not responding | Running but hasn't answered for 10 seconds. Input.Observer restarts it. |
| Disabled | Switched off with Disable. |
| Auto-disabled -- failed to start | Failed to start several times in a row. Input.Observer stopped trying ("When a plugin fails" below). |
| Closed by the plugin | The plugin closed itself on purpose. It stays closed until you choose Retry, disable and enable it, or restart Input.Observer. |
The buttons in Actions:
| Button | Shown when | What it does |
|---|---|---|
| Use as renderer | A drawing plugin that is switched on and isn't the renderer | Makes it the renderer (below). |
| Settings (gear) | The plugin has settings and is running or not in use | Opens its settings (below). |
| Preview / Stop preview | The plugin draws a trail, a hint or messages | Shows what it draws (below). |
| Retry | Auto-disabled, or closed by the plugin | Starts it again and clears the failure count. |
| Allow call-backs / Block call-backs | The plugin provides script functions or a script engine | See "Call-backs" below. |
| Enable / Disable | Always | Starts or stops the plugin and keeps it registered. |
| Remove | Always | Stops the plugin and forgets it. The program itself is not deleted. |
Disable and Remove ask first when scripts in your configuration need the plugin — scripts that run in its script engine or call its functions — and list them. Those scripts stop working while the plugin is gone.
Adding a plugin
- Choose Add Plugin… ① and pick the plugin's program (
.exe). - Input.Observer starts the program once to ask for its name, then starts it again and checks that it connects and answers. This takes a few seconds.
- If it passes, the plugin is added at the top of the list and keeps running. If it draws trails, hints or messages, it also becomes the renderer, and a "Renderer changed" note says so.
If the plugin doesn't pass, "Couldn't Add Plugin" explains why: the file isn't there, the program didn't answer or answered wrongly (it may not be an Input.Observer plugin), it took too long, its name is already used by another registered plugin, or its script functions or script engine use names another plugin already uses. In each case nothing is added.
Input.Observer keeps the plugin's path relative to its own folder when the plugin is inside it, so a plugin installed beside Input.Observer keeps working if Input.Observer moves.
Trusting a plugin
- Adding a plugin runs it. Step 2 starts the program at once, with your permissions, and from then on Input.Observer starts it every time it starts. Input.Observer doesn't check who made a plugin or whether it is signed. Add only programs from sources you trust, as you would before running any program.
- A plugin runs as its own program. It never runs inside Input.Observer, and Input.Observer never waits for a plugin while handling your mouse and keyboard, so a slow or broken plugin can't make your input lag.
- A plugin that draws gets your gesture strokes and the text of hints and messages, so it can draw them.
- A plugin with script functions gets the values scripts pass to those functions.
The renderer
The renderer is the one plugin that draws for Input.Observer: the trail styles, and hints and messages when those are set to Match style on the Appearance page. Only one plugin is the renderer at a time. A standard installation registers the Styles plugin as the renderer.
To make another drawing plugin the renderer, choose Use as renderer on its row. The engine switches at once: the new renderer starts, the previous one stops and shows Not in use, and the trail, hints and messages the new plugin can draw are set to it. Your choices on the Appearance page then decide what it draws (Appearance). A plugin that offers no styles shows as a single tile in the gallery, under its own name; its own settings decide how it draws.
Disabling or removing the renderer leaves no renderer: Input.Observer's classic trail, hint window and message window draw until you choose another.
Not in use
Input.Observer doesn't run a plugin that has nothing to do. A drawing plugin runs only while it is the renderer and something on the Appearance page is set to it. A plugin that provides script functions or a script engine always runs while it is enabled.
A plugin that isn't in use is started for a moment when you open its settings or preview it, and goes back to
Not in use afterwards. The Styles plugin stops about a minute after your last change in its settings. A
script's PluginSendMessage call to a drawing plugin that isn't running fails with an error saying so; it does
not start the plugin.
Plugin settings
The gear on a plugin's row opens its settings:
- A plugin marked Settings here shows its settings in a window drawn by the configuration window, with a section list on the left. The Styles plugin's are described in Gesture trails.
- Any other plugin with Settings opens its own settings window.
A plugin that isn't running is started first, so the window may take a few seconds to fill. Changes take effect at once and are saved by the plugin itself, in its own file beside your configuration file; they don't wait for Apply, and Discard doesn't undo them. Restore defaults puts the selected section back to the plugin's defaults. If a change can't be made, a note in the window says why: the plugin didn't start or doesn't offer these settings, didn't answer in time, refused the change, or made it but couldn't save it.
Preview
Preview shows what a drawing plugin would draw, without a real gesture: a trail that follows your pointer, a sample hint and a sample message. Right-click to see the trail end and start again; the right-click opens nothing while previewing.
While a preview runs, gestures are paused everywhere, and a banner on the page says so. The preview ends when you press Esc, choose Stop preview, leave the Plugins page, or the plugin stops. A preview can't start while a macro recording or gesture training is running.
When a plugin fails
Input.Observer checks every running plugin every 5 seconds.
- A plugin that stops answering for 10 seconds (two missed checks) shows Not responding and is restarted.
- A plugin that exits unexpectedly is restarted 10 seconds later.
- A plugin that fails to start is tried again after 2, 5 and 10 seconds. After the third failed attempt it is Auto-disabled -- failed to start and Input.Observer leaves it alone, even across restarts, until you choose Retry. The failure count goes back to zero once a plugin has run without trouble for 5 minutes.
- A plugin that closes itself on purpose shows Closed by the plugin and isn't restarted until you choose Retry, disable and enable it, or restart Input.Observer.
While the renderer is down, Input.Observer's classic trail, hint window and message window draw in its place, and the Appearance page says so with a Restart button. Each time this happens, a line goes to the console's System section (Console).
When Input.Observer starts, it starts each plugin that has work to do and waits up to about 5 seconds for each; the splash screen names the plugin it is loading. A plugin that misses that time is picked up a little later. When Input.Observer exits, it closes every plugin, and a plugin can never keep running after Input.Observer has stopped. In Safe Mode no plugin is started (Troubleshooting).
Call-backs
A plugin that provides script functions or a script engine may ask to run Input.Observer script while it handles a call. This is blocked unless you choose Allow call-backs on its row and confirm. Allow it only for a plugin you trust: its requests can then do anything a script here can — press keys, move and close windows, run programs — including in windows running as administrator, which the plugin can't reach on its own. Block call-backs takes the permission away again.