This extension makes it possible to create user interfaces for LV2 plugins.

UIs are implemented as an LV2UI_Descriptor loaded via lv2ui_descriptor() in a shared library, and are distributed in bundles just like plugins.

UIs are associated with plugins in data:

@prefix ui: <http://lv2plug.in/ns/extensions/ui#> .

<http://my.plugin>   ui:ui      <http://my.pluginui> .
<http://my.pluginui> a          ui:X11UI ;
                     lv2:binary <myui.so> .

where http://my.plugin is the URI of the plugin, http://my.pluginui is the URI of the plugin UI and myui.so is the relative URI to the shared object file.

While it is possible to have the plugin UI and the plugin in the same shared object file, it is a good idea to keep them separate so that hosts can avoid loading the UI code if they do not need it. A UI MUST specify its class in the RDF data (X11UI in the above example). The class defines what type the UI is, for example what graphics toolkit it uses. Any type of UI class can be defined separately from this extension.

It is possible to have multiple UIs for the same plugin, or to have the UI for a plugin in a different bundle from the actual plugin. This allows plugin UIs to be written independently.

Note that the process that loads the shared object file containing the UI code and the process that loads the shared object file containing the actual plugin implementation are not necessarily the same process (and not even necessarily on the same machine). This means that plugin and UI code MUST NOT use singletons and global variables and expect them to refer to the same objects in the UI and the actual plugin. The function callback interface defined in this header is the only method of communication between UIs and plugin instances (extensions may define more, though this is discouraged unless absolutely necessary since the significant benefits of network transparency and serialisability are lost).

UI functionality may be extended via features, much like plugins:

<http://my.pluginui> lv2:requiredFeature <http://my.feature> .
<http://my.pluginui> lv2:optionalFeature <http://my.feature> .

The rules for a UI with a required or optional feature are identical to those of lv2:Plugin instances: if a UI declares a feature as required, the host is NOT allowed to load it unless it supports that feature; and if it does support a feature, it MUST pass an appropriate LV2_Feature struct to the UI's instantiate() method. This extension defines several standard features for common functionality.

UIs written to this specification do not need to be thread-safe. All functions may only be called in the UI thread. There is only one UI thread (for toolkits, the one the UI main loop runs in). There is no requirement that a UI actually be a graphical widget.

Note that UIs are completely separate from plugins. From the plugin's perspective, control from a UI is indistinguishable from any other control, as it all occcurs via ports.

Index

ClassesPropertiesInstances

Classes

CocoaUI

Class
LabelCocoa UI
Subclass ofUI

A UI where the widget is a pointer to a NSView.

This is the native UI type on Mac OS X.

Gtk3UI

Class
LabelGTK3 UI
Subclass ofUI

A UI where the widget is a pointer to a Gtk+ 3.0 GtkWidget.

The host must guarantee that the Gtk+ 3 library has been initialised and the Glib main loop is running before the UI is instantiated. Note that this UI type is not suitable for binary distribution since multiple versions of Gtk can not be used in the same process.

GtkUI

Class
LabelGTK2 UI
Subclass ofUI

A UI where the widget is a pointer to a Gtk+ 2.0 GtkWidget.

The host must guarantee that the Gtk+ 2 library has been initialised and the Glib main loop is running before the UI is instantiated. Note that this UI type is not suitable for binary distribution since multiple versions of Gtk can not be used in the same process.

PortNotification

Class
LabelPort Notification
In domain ofnotifyType
plugin
portIndex
protocol
In range ofportNotification

A description of port updates that a host must send a UI.

This describes which ports the host must send notifications to the UI about. The port must be specific either by index, using the portIndex property, or symbol, using the lv2:symbol property. Since port indices are not guaranteed to be stable, using the symbol is recommended, and the inde MUST NOT be used except by UIs that are shipped in the same bundle as the corresponding plugin.

Restriction on plugin
owl:cardinality 1
A PortNotification MUST have exactly one ui:plugin.

PortProtocol

Class
LabelPort Protocol
Subclass oflv2:Feature
In range ofprotocol

A method to communicate port data between a UI and plugin.

A PortProtocol MUST define:

Port Type
Which plugin port types the buffer type is valid for.
Feature Data
What data (if any) should be passed in the LV2_Feature.

A PortProtocol for an output port MUST define:

Update Frequency
When the host should call port_event().
Update Format
The format of the data in the buffer passed to port_event().
Options
The format of the options passed to subscribe() and unsubscribe().

A PortProtocol for an input port MUST define:

Write Format
The format of the data in the buffer passed to write_port().
Write Effect
What happens when the UI calls write_port().

For an example, see floatProtocol or peakProtocol.

PortProtocol is a subclass of lv2:Feature, so UIs use lv2:optionalFeature and lv2:requiredFeature to specify which PortProtocols they want to use.

Qt4UI

Class
LabelQt4 UI
Subclass ofUI

A UI where the widget is a pointer to a Qt4 QWidget.

The host must guarantee that the Qt4 library has been initialised and the Qt4 main loop is running before the UI is instantiated. Note that this UI type is not suitable for binary distribution since multiple versions of Qt can not be used in the same process.

Qt5UI

Class
LabelQt5 UI
Subclass ofUI

A UI where the widget is a pointer to a Qt5 QWidget.

The host must guarantee that the Qt5 library has been initialised and the Qt5 main loop is running before the UI is instantiated. Note that this UI type is not suitable for binary distribution since multiple versions of Qt can not be used in the same process.

UI

Class
LabelUser Interface
Superclass ofCocoaUI
Gtk3UI
GtkUI
Qt4UI
Qt5UI
WindowsUI
X11UI
In domain ofportNotification
In range ofui

A UI for an LV2 plugin.

WindowsUI

Class
LabelWindows UI
Subclass ofUI

A UI where the widget is a Windows HWND window ID.

Note that the LV2UI_Widget for this type of UI is not a pointer, but should be interpreted directly as a HWND. This is the native UI type on Microsoft Windows.

X11UI

Class
LabelX11 UI
Subclass ofUI

A UI where the widget is an X11 Window window ID.

Note that the LV2UI_Widget for this type of UI is not a pointer, but should be interpreted directly as an X11 Window ID. This is the native UI type on most POSIX systems.

Properties

backgroundColor

Property
Labelbackground color
TypeDatatype Property

The background color of the host's UI.

The background color of the host's UI. The host can pass this as an option so that UIs can integrate nicely with the host window around it.

Hosts should pass this as an option to UIs with an integer RGBA32 color value. If the value is a 32-bit integer, it is guaranteed to be in RGBA32 format, but the UI must check the value type and not assume this, to allow for other types of color in the future.

binary

Property
Labelbinary
TypeObject Property
owl:deprecated true
owl:sameAs lv2:binary
Deprecated

The shared library that a UI resides in.

This property is redundant and deprecated: new UIs should use lv2:binary instead, however hosts must still support binary.

foregroundColor

Property
Labelforeground color
TypeDatatype Property

The foreground color of the host's UI.

The foreground color of the host's UI. The host can pass this as an option so that UIs can integrate nicely with the host window around it.

Hosts should pass this as an option to UIs with an integer RGBA32 color value. If the value is a 32-bit integer, it is guaranteed to be in RGBA32 format, but the UI must check the value type and not assume this, to allow for other types of color in the future.

notifyType

Property
Labelnotify type
DomainPortNotification
TypeObject Property

A particular type that the UI should be notified of.

Specifies a particular type that the UI should be notified of.

This is useful for message-based ports where several types of data can be present, but only some are interesting to the UI. For example, if UI control is multiplexed in the same port as MIDI, this property can be used to ensure that only the relevant events are forwarded to the UI, and not potentially high frequency MIDI data.

plugin

Property
Labelplugin
DomainPortNotification
Rangelv2:Plugin
TypeObject Property

The plugin a portNotification applies to.

portIndex

Property
Labelport index
DomainPortNotification
Rangexsd:decimal
TypeDatatype Property

The index of the port a portNotification applies to.

portNotification

Property
Labelport notification
DomainUI
RangePortNotification
TypeObject Property

Specifies a port notification that is required by a UI.

Specifies that a UI should receive notifications about changes to a particular port's value via LV2UI_Descriptor::port_event().

For example:

eg:ui
    a ui:X11UI ;
    ui:portNotification [
        ui:plugin eg:plugin ;
        lv2:symbol "gain" ;
        ui:protocol ui:floatProtocol
    ] .

protocol

Property
Labelprotocol
DomainPortNotification
RangePortProtocol
TypeObject Property

The protocol to be used for this notification.

scaleFactor

Property
Labelscale factor
Rangexsd:float
TypeDatatype Property

Scale factor for high resolution screens.

HiDPI (High Dots Per Inch) displays have a high resolution on a relatively small form factor. Many systems use a scale factor to compensate for this, so for example, a scale factor of 2 means things are drawn twice as large as normal.

Hosts can pass this as an option to UIs to communicate this information, so that the UI can draw at an appropriate scale.

ui

Property
Labeluser interface
Domainlv2:Plugin
RangeUI
TypeObject Property

Relates a plugin to a UI that applies to it.

updateRate

Property
Labelupdate rate
Rangexsd:float
TypeDatatype Property

The target rate, in Hz, to send updates to the UI.

windowTitle

Property
Labelwindow title
Rangexsd:string
TypeDatatype Property

The title for the window shown by LV2UI_Show_Interface.

Instances

fixedSize

Instance
Labelfixed size
Typelv2:Feature

Non-resizable UI that will never resize itself.

If a UI has this feature, it indicates the same thing as noUserResize, and additionally that the UI will not resize itself on its own. That is, the UI will always remain the same size. This feature may not make sense for all UI types. The data pointer for this feature should always be set to NULL.

floatProtocol

Instance
Labelfloat protocol
TypePortProtocol

A protocol for transferring single floating point values.

A protocol for transferring single floating point values. The rules for this protocol are:

Port Type
lv2:ControlPort
Feature Data
None.
Update Frequency
The host SHOULD call port_event() as soon as possible when the port value has changed, but there are no timing guarantees.
Update Format
A single float.
Options
None.
Write Format
A single float.
Write Effect
The host SHOULD set the port to the received value as soon as possible, but there is no guarantee that run() actually sees this value.

idleInterface

Instance
Labelidle interface
Typelv2:ExtensionData
lv2:Feature

A feature that provides a callback for the host to drive the UI.

To support this feature, the UI should list it as a lv2:optionalFeature or lv2:requiredFeature in its data, and also as lv2:extensionData. When the UI's extension_data() is called with this URI (LV2_UI__idleInterface), it should return a pointer to an LV2UI_Idle_Interface.

To indicate support, the host should pass a feature to instantiate() with this URI, with NULL for data.

makeSONameResident

Instance
Labelmake SO name resident
Typelv2:Feature
owl:deprecated true
Deprecated

UI binary must not be unloaded.

This feature was intended to support UIs that link against toolkit libraries which may not be unloaded during the lifetime of the host. This is better achieved by using the appropriate flags when linking the UI, for example gcc -Wl,-z,nodelete.

noUserResize

Instance
Labelno user resize
Typelv2:Feature

Non-resizable UI.

If a UI has this feature, it indicates that it does not make sense to let the user resize the main widget, and the host should prevent that. This feature may not make sense for all UI types. The data pointer for this feature should always be set to NULL.

parent

Instance
Labelparent
Typelv2:Feature

The parent for a UI.

This feature can be used to pass a parent that the UI should be a child of. The format of data pointer of this feature is determined by the UI type, and is generally the same type as the LV2UI_Widget that the UI would return. For example, for a X11UI, the parent should be a Window. This is particularly useful for embedding, where the parent often must be known at construction time for embedding to work correctly.

UIs should not require this feature unless it is necessary for them to work at all, but hosts should provide it whenever possible.

peakProtocol

Instance
Labelpeak protocol
TypePortProtocol

A protocol for sending continuous peak measurements of an audio signal.

This port protocol defines a way for the host to send continuous peak measurements of the audio signal at a certain port to the UI. The intended use is visualisation, for example an animated meter widget that shows the level of the audio input or output.

A contiguous sequence of audio samples for which a peak value has been computed is called a measurement period.

The rules for this protocol are:

Port Type
lv2:AudioPort
Feature Data
None.
Update Frequency
The host SHOULD call port_event() at regular intervals. The measurement periods used for calls to port_event() for the same port SHOULD be contiguous (i.e. the measurement period for one call should begin right after the end of the measurement period for the previous call ends) unless the UI has removed and re-added the port subscription between those calls. However, UIs MUST NOT depend on either the regularity of the calls or the contiguity of the measurement periods; hosts may change the call rate or skip calls for performance or other reasons. Measurement periods for different calls to port_event() for the same port MUST NOT overlap.
Update Format
A single LV2UI_Peak_Data object.
Options
None.
Write Format
None.
Write Effect
None.

portMap

Instance
Labelport map
Typelv2:Feature

A feature for accessing the index of a port by symbol.

This makes it possible to implement and distribute UIs separately from the plugin binaries they control.

This feature corresponds to the LV2UI_Port_Index struct, which should be passed with the URI LV2_UI__portIndex.

portSubscribe

Instance
Labelport subscribe
Typelv2:Feature

A feature for dynamically subscribing to updates from a port.

This makes it possible for a UI to explicitly request a particular style of update from a port at run-time, in a more flexible and powerful way than listing subscriptions statically allows.

This feature corresponds to the LV2UI_Port_Subscribe struct, which should be passed with the URI LV2_UI__portSubscribe.

requestValue

Instance
Labelrequest value
Typelv2:Feature

A feature to request a parameter value from the user via the host.

This allows a plugin UI to request a new parameter value using the host's UI, for example by showing a dialog or integrating with the host's built-in content browser. This should only be used for complex parameter types where the plugin UI is not capable of showing the expected native platform or host interface to choose a value, such as file path parameters.

This feature corresponds to the LV2UI_Request_Value struct, which should be passed with the URI LV2_UI__requestValue.

resize

Instance
Labelresize
Typelv2:ExtensionData
lv2:Feature

A feature that control of, and notifications about, a UI's size.

This feature corresponds to the LV2UI_Resize struct, which should be passed with the URI LV2_UI__resize. This struct may also be provided by the UI as extension data using the same URI, in which case it is used by the host to request that the UI change its size.

showInterface

Instance
Labelshow interface
Typelv2:ExtensionData

An interface for showing and hiding a window for a UI.

This allows UIs to gracefully degrade to separate windows when the host is unable to embed the UI widget for whatever reason. When the UI's extension_data() is called with this URI (LV2_UI__showInterface), it should return a pointer to an LV2UI_Show_Interface.

touch

Instance
Labeltouch
Typelv2:Feature

A feature to notify that the user has grabbed a port control.

This is useful for automation, so the host can allow the user to take control of a port, even if that port would otherwise be automated (much like grabbing a physical motorised fader).

It can also be used for MIDI learn or in any other situation where the host needs to do something with a particular control and it would be convenient for the user to select it directly from the plugin UI.

This feature corresponds to the LV2UI_Touch struct, which should be passed with the URI LV2_UI__touch.

History

Version 2.22 (2020-04-26)
  • Add ui:requestValue feature.
  • Add ui:scaleFactor, ui:foregroundColor, and ui:backgroundColor properties.
  • Deprecate ui:binary.
Version 2.20 (2015-07-25)
  • Improve documentation.
  • Add missing property labels.
Version 2.18 (2014-08-08)
  • Add show interface so UIs can gracefully degrade to separate windows if hosts can not use their widget directly.
  • Fix identifier typos in documentation.
Version 2.16 (2014-01-04)
  • Fix LV2_UI_INVALID_PORT_INDEX identifier in documentation.
Version 2.14 (2013-03-18)
  • Add idle interface so native UIs and foreign toolkits can drive their event loops.
  • Add ui:updateRate property.
Version 2.12 (2012-12-01)
  • Fix incorrect linker flag in ui:makeSONameResident documentation.
Version 2.10 (2012-10-14)
  • Add types for WindowsUI, CocoaUI, and Gtk3UI.
  • Use consistent label style.
  • Add missing LV2_SYMBOL_EXPORT declaration for lv2ui_descriptor prototype.
Version 2.8 (2012-04-17)
  • Add ui:parent and ui:resize.
  • Add support for referring to ports by symbol.
  • Add ui:portMap for accessing ports by symbol, allowing for UIs to be distributed separately from plugins.
  • Add port protocols and a dynamic notification subscription mechanism, for more flexible communication, and audio port metering without control port kludges.
  • Add touch feature to notify the host that the user has grabbed a control.
  • Merge with unified LV2 package.
Version 2.4 (2011-11-21)
  • Deprecate ui:makeSONameResident.
  • Add Qt4 and X11 widget types.
  • Install header to URI-based system path.
  • Add pkg-config file.
  • Make ui.ttl a valid OWL 2 DL ontology.
Version 2.2 (2011-05-26)
  • Add build system (for installation).
  • Convert documentation to HTML and use lv2:documentation.
  • Use lv2:Specification to be discovered as an extension.
Version 2.0 (2010-10-06)
  • Initial release.