ui
type: Ontology
imports: lv2core
documentation: This extension defines an interface that can be used in LV2 plugins and hosts to create UIs for plugins. The UIs are similar to plugins and reside in shared object files in an LV2 bundle. UIs are associated with a plugin in RDF using the triples: @prefix ui: <http://lv2plug.in/ns/extensions/ui#> . <http://my.plugin> ui:ui <http://my.pluginui> . <http://my.pluginui> a ui:GtkUI ; ui: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 probably a good idea to keep them separate so that hosts that don't want UIs don't have to load the UI code. A UI MUST specify its class in the RDF data (ui:GtkUI in the above example). The class defines what type the UI is, e.g. 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 way people other than the plugin author can write plugin UIs independently without editing the original plugin bundle. 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 can 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). Since the LV2 specification itself allows fo…

LV2 UI
type: Class
subclass of: Resource
comment: A UI for an LV2 plugin

GtkUI
type: Class
subclass of: LV2 UI
comment: A UI where the LV2_Widget is a pointer to a Gtk+ 2.0 compatible GtkWidget, and the host guarantees that the Gtk+ library has been initialised and the Glib main loop is running before a UI of this type is instantiated.

Qt4UI
type: Class
subclass of: LV2 UI
comment: A UI where the LV2_Widget is a pointer to a Qt4 compatible QWidget, and the host guarantees that the Qt4 library has been initialised and the Qt4 main loop is running before a UI of this type is instantiated.

X11UI
type: Class
subclass of: LV2 UI
comment: A UI where the LV2_Widget is an X11 window ID. Note this is actually an integer, i.e. the LV2_Widget is not a pointer to an X11 window ID, but should be itself taken as an integer value.

makeSONameResident
type: Feature
deprecated: true
documentation: DEPRECATED 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, e.g. gcc -Wl,nodelete.

noUserResize
type: Feature
documentation: If a UI requires 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 the LV2_Feature for this feature should always be set to NULL.

fixedSize
type: Feature
documentation: If a UI requires this feature it indicates the same thing as ui:noUserResize, and additionally it means that the UI will not resize the main widget on its own - it will always remain the same size (e.g. a pixmap based GUI). This feature may not make sense for all UI types. The data pointer for the LV2_Feature for this feature should always be set to NULL.

parent
type: Feature
documentation: The parent for the UI. This feature can be used to pass a parent (e.g. a widget, container, canvas, etc.) 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 LV2_Widget the UI would return (e.g. for a GtkUI the data would be a pointer to a GtkWidget which is a GtkContainer). This is particularly useful for cross-toolkit 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 absolutely necessary for them to work at all.

PortNotification
type: Class
subclass of: Restriction
  on property: plugin
  some values from: Plugin
  cardinality: 1
  comment: A PortNotification MUST have exactly one ui:plugin which is a lv2:Plugin.
subclass of: Restriction
  on property: portIndex
  some values from: decimal
  cardinality: 1
  comment: A PortNotification MUST have exactly one ui:portIndex which is an xsd:decimal.
comment: Port Notification

portNotification
type: Property
type: ObjectProperty
domain: LV2 UI
range: PortNotification
documentation: Indicates that a UI should receive notification (via LV2UI_Descriptor::port_event()) when a particular port's value changes.

plugin
type: Property
type: ObjectProperty
domain: PortNotification
range: Plugin
comment: The plugin a portNotification applies to.

portIndex
type: Property
type: DatatypeProperty
domain: PortNotification
range: decimal
comment: The index of the port a portNotification applies to.