This extension defines an interface that can be used to create UIs for plugins. The UIs are code that reside in shared object files in an LV2 bundle and are referenced in the RDF data using the triples @prefix ui: <http://lv2plug.in/ns/ext/ui#> . <http://my.pluginui> a ui-gtk:GtkUI ; lv2:appliesTo <http://my.plugin> ; 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 and the class MUST be a proper subclass of ui:UI, in this case ui-gtk:GtkUI. The class defines what type the UI is, e.g. what graphics toolkit it uses. There are no UI classes defined in this extension, those are specified separately (and anyone can define their own). It's entirely 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. It is also possible to have one UI that works with several different plugins. UIs should also be written in such a way that the host may load several instances of an UI, or different UIs, and use them with the same plugin instance. 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 do not have to be the same. There are many valid reasons for having the plugin and the UI in different processes, or even on different machines. This means that you 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 the header lv2_ui.h is all you can expect to work.
The class which represents an LV2 plugin UI. To be used by a host a UI MUST have at least the following properties: rdf:type (with object a proper subclass of ui:UI) doap:name (one without language tag) lv2:binary (with a shared object file as object) lv2:appliesTo (with a LV2 plugin as object) The rdf:type of an UI is used by the host to decide whether it supports the UI and how to handle the LV2_UI_Widget object that is returned by the UIs get_widget() function. For example, a type of ui-gtk:GtkGUI might tell the host that LV2_UI_Widget is a pointer to an object of a type defined in the Gtk+ library. No UI types are defined in this extension, that is intentionally left for other extensions. The doap:name property should be at most a few words in length using title capitalization, e.g. "Flashy Mixer GUI". Use lv2:documentation for more detailed descriptions. UIs may have optional or required features, specified using lv2:optionalFeature or lv2:requiredFeature. The same rules apply here as for plugins; a host MUST pass the LV2_Feature objects for all features it supports to the UI's instantiate() function, a host SHOULD NOT try to instantiate an UI if it doesn't support all of its required features, and an UI MUST fail to instantiate if the host doesn't pass all required features to instantiate(). For details about the C API used to load UIs, see the file lv2_ui.h.
A PortProtocol defines a certain way of communicating port data between UI and plugin. PortProtocols can be specified in additional extensions, and those extensions MUST specify: Which plugin port types the buffer type is valid for When the host should call port_event() in LV2_UI_Descriptor The format of the data in the buffer passed to port_event() The format of the data in the buffer passed to write_port() What happens when the UI calls write_port() in LV2_UI_Host_Descriptor What data (if any) should be passed in the LV2_Feature data pointer. For an example, see ui:floatControl. PortProtocol is a subclass of lv2:Feature, so UIs use lv2:optionalFeature and lv2:requiredFeature to specify which PortProtocols they want to use.
The rules (see ui:PortProtocol) for this port protocol are: This PortProtocol is valid for ports with the type lv2:ControlPort. The host SHOULD call port_event() as soon as possible when the port value has changed, but the plugin MUST NOT depend on a call for every change or the timing of the calls. However, the host MUST do the calls in the same order that the value changes occur in. The format of the data in the buffer passed to port_event() is a single float, and the buffer size is sizeof(float). Same as 3. The host SHOULD change the port value as soon as possible when write_port() is called, but the UI MUST NOT depend on a change for every call or the timing of the changes. However, the host MUST do the changes in the same order that the function calls occur in. The data pointer in the LV2_Feature object for this feature should be NULL.