diff options
Diffstat (limited to 'lv2/ui')
| -rw-r--r-- | lv2/ui/lv2-ui.doap.ttl | 146 | ||||
| -rw-r--r-- | lv2/ui/manifest.ttl | 8 | ||||
| -rw-r--r-- | lv2/ui/ui.h | 445 | ||||
| -rw-r--r-- | lv2/ui/ui.ttl | 461 |
4 files changed, 1060 insertions, 0 deletions
diff --git a/lv2/ui/lv2-ui.doap.ttl b/lv2/ui/lv2-ui.doap.ttl new file mode 100644 index 0000000..8b804b1 --- /dev/null +++ b/lv2/ui/lv2-ui.doap.ttl @@ -0,0 +1,146 @@ +@prefix dcs: <http://ontologi.es/doap-changeset#> . +@prefix doap: <http://usefulinc.com/ns/doap#> . +@prefix foaf: <http://xmlns.com/foaf/0.1/> . +@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . + +<http://lv2plug.in/ns/extensions/ui> + a doap:Project ; + doap:license <http://opensource.org/licenses/isc> ; + doap:name "LV2 UI" ; + doap:shortdesc "LV2 plugin UIs of any type." ; + doap:created "2006-00-00" ; + doap:developer <http://lv2plug.in/ns/meta#larsl> ; + doap:maintainer <http://drobilla.net/drobilla#me> ; + doap:release [ + doap:revision "2.20" ; + doap:created "2015-07-25" ; + doap:file-release <http://lv2plug.in/spec/lv2-1.14.0.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Improve documentation." + ] , [ + rdfs:label "Add missing property labels." + ] + ] + ] , [ + doap:revision "2.18" ; + doap:created "2014-08-08" ; + doap:file-release <http://lv2plug.in/spec/lv2-1.10.0.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Add show interface so UIs can gracefully degrade to separate windows if hosts can not use their widget directly." + ] , [ + rdfs:label "Fix identifier typos in documentation." + ] + ] + ] , [ + doap:revision "2.16" ; + doap:created "2014-01-04" ; + doap:file-release <http://lv2plug.in/spec/lv2-1.8.0.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Fix LV2_UI_INVALID_PORT_INDEX identifier in documentation." + ] + ] + ] , [ + doap:revision "2.14" ; + doap:created "2013-03-18" ; + doap:file-release <http://lv2plug.in/spec/lv2-1.6.0.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Add idle interface so native UIs and foreign toolkits can drive their event loops." + ] , [ + rdfs:label "Add ui:updateRate property." + ] + ] + ] , [ + doap:revision "2.12" ; + doap:created "2012-12-01" ; + doap:file-release <http://lv2plug.in/spec/lv2-1.4.0.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Fix incorrect linker flag in ui:makeSONameResident documentation." + ] + ] + ] , [ + doap:revision "2.10" ; + doap:created "2012-10-14" ; + doap:file-release <http://lv2plug.in/spec/lv2-1.2.0.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Add types for WindowsUI, CocoaUI, and Gtk3UI." + ] , [ + rdfs:label "Use consistent label style." + ] , [ + rdfs:label "Add missing LV2_SYMBOL_EXPORT declaration for lv2ui_descriptor prototype." + ] + ] + ] , [ + doap:revision "2.8" ; + doap:created "2012-04-17" ; + doap:file-release <http://lv2plug.in/spec/lv2-1.0.0.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Add ui:parent and ui:resize." + ] , [ + rdfs:label "Add support for referring to ports by symbol." + ] , [ + rdfs:label "Add ui:portMap for accessing ports by symbol, allowing for UIs to be distributed separately from plugins." + ] , [ + rdfs:label "Add port protocols and a dynamic notification subscription mechanism, for more flexible communication, and audio port metering without control port kludges." + ] , [ + rdfs:label "Add touch feature to notify the host that the user has grabbed a control." + ] , [ + rdfs:label "Merge with unified LV2 package." + ] + ] + ] , [ + doap:revision "2.4" ; + doap:created "2011-11-21" ; + doap:file-release <http://lv2plug.in/spec/lv2-ui-2.4.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Deprecate ui:makeSONameResident." + ] , [ + rdfs:label "Add Qt4 and X11 widget types." + ] , [ + rdfs:label "Install header to URI-based system path." + ] , [ + rdfs:label "Add pkg-config file." + ] , [ + rdfs:label "Make ui.ttl a valid OWL 2 DL ontology." + ] + ] + ] , [ + doap:revision "2.2" ; + doap:created "2011-05-26" ; + doap:file-release <http://lv2plug.in/spec/lv2-ui-2.2.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Add build system (for installation)." + ] , [ + rdfs:label "Convert documentation to HTML and use lv2:documentation." + ] , [ + rdfs:label "Use lv2:Specification to be discovered as an extension." + ] + ] + ] , [ + doap:revision "2.0" ; + doap:created "2010-10-06" ; + doap:file-release <http://lv2plug.in/spec/lv2-ui-2.0.tar.gz> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Initial release." + ] + ] + ] . diff --git a/lv2/ui/manifest.ttl b/lv2/ui/manifest.ttl new file mode 100644 index 0000000..384bf2e --- /dev/null +++ b/lv2/ui/manifest.ttl @@ -0,0 +1,8 @@ +@prefix lv2: <http://lv2plug.in/ns/lv2core#> . +@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . + +<http://lv2plug.in/ns/extensions/ui> + a lv2:Specification ; + lv2:minorVersion 2 ; + lv2:microVersion 20 ; + rdfs:seeAlso <ui.ttl> .
\ No newline at end of file diff --git a/lv2/ui/ui.h b/lv2/ui/ui.h new file mode 100644 index 0000000..450a41e --- /dev/null +++ b/lv2/ui/ui.h @@ -0,0 +1,445 @@ +/* + LV2 UI Extension + Copyright 2009-2016 David Robillard <d@drobilla.net> + Copyright 2006-2011 Lars Luthman <lars.luthman@gmail.com> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +/** + @defgroup ui User Interfaces + + User interfaces of any type for plugins, + <http://lv2plug.in/ns/extensions/ui> for details. + + @{ +*/ + +#ifndef LV2_UI_H +#define LV2_UI_H + +#include "lv2/core/lv2.h" + +#include <stdbool.h> +#include <stdint.h> + +#define LV2_UI_URI "http://lv2plug.in/ns/extensions/ui" ///< http://lv2plug.in/ns/extensions/ui +#define LV2_UI_PREFIX LV2_UI_URI "#" ///< http://lv2plug.in/ns/extensions/ui# + +#define LV2_UI__CocoaUI LV2_UI_PREFIX "CocoaUI" ///< http://lv2plug.in/ns/extensions/ui#CocoaUI +#define LV2_UI__Gtk3UI LV2_UI_PREFIX "Gtk3UI" ///< http://lv2plug.in/ns/extensions/ui#Gtk3UI +#define LV2_UI__GtkUI LV2_UI_PREFIX "GtkUI" ///< http://lv2plug.in/ns/extensions/ui#GtkUI +#define LV2_UI__PortNotification LV2_UI_PREFIX "PortNotification" ///< http://lv2plug.in/ns/extensions/ui#PortNotification +#define LV2_UI__PortProtocol LV2_UI_PREFIX "PortProtocol" ///< http://lv2plug.in/ns/extensions/ui#PortProtocol +#define LV2_UI__Qt4UI LV2_UI_PREFIX "Qt4UI" ///< http://lv2plug.in/ns/extensions/ui#Qt4UI +#define LV2_UI__Qt5UI LV2_UI_PREFIX "Qt5UI" ///< http://lv2plug.in/ns/extensions/ui#Qt5UI +#define LV2_UI__UI LV2_UI_PREFIX "UI" ///< http://lv2plug.in/ns/extensions/ui#UI +#define LV2_UI__WindowsUI LV2_UI_PREFIX "WindowsUI" ///< http://lv2plug.in/ns/extensions/ui#WindowsUI +#define LV2_UI__X11UI LV2_UI_PREFIX "X11UI" ///< http://lv2plug.in/ns/extensions/ui#X11UI +#define LV2_UI__binary LV2_UI_PREFIX "binary" ///< http://lv2plug.in/ns/extensions/ui#binary +#define LV2_UI__fixedSize LV2_UI_PREFIX "fixedSize" ///< http://lv2plug.in/ns/extensions/ui#fixedSize +#define LV2_UI__idleInterface LV2_UI_PREFIX "idleInterface" ///< http://lv2plug.in/ns/extensions/ui#idleInterface +#define LV2_UI__noUserResize LV2_UI_PREFIX "noUserResize" ///< http://lv2plug.in/ns/extensions/ui#noUserResize +#define LV2_UI__notifyType LV2_UI_PREFIX "notifyType" ///< http://lv2plug.in/ns/extensions/ui#notifyType +#define LV2_UI__parent LV2_UI_PREFIX "parent" ///< http://lv2plug.in/ns/extensions/ui#parent +#define LV2_UI__plugin LV2_UI_PREFIX "plugin" ///< http://lv2plug.in/ns/extensions/ui#plugin +#define LV2_UI__portIndex LV2_UI_PREFIX "portIndex" ///< http://lv2plug.in/ns/extensions/ui#portIndex +#define LV2_UI__portMap LV2_UI_PREFIX "portMap" ///< http://lv2plug.in/ns/extensions/ui#portMap +#define LV2_UI__portNotification LV2_UI_PREFIX "portNotification" ///< http://lv2plug.in/ns/extensions/ui#portNotification +#define LV2_UI__portSubscribe LV2_UI_PREFIX "portSubscribe" ///< http://lv2plug.in/ns/extensions/ui#portSubscribe +#define LV2_UI__protocol LV2_UI_PREFIX "protocol" ///< http://lv2plug.in/ns/extensions/ui#protocol +#define LV2_UI__floatProtocol LV2_UI_PREFIX "floatProtocol" ///< http://lv2plug.in/ns/extensions/ui#floatProtocol +#define LV2_UI__peakProtocol LV2_UI_PREFIX "peakProtocol" ///< http://lv2plug.in/ns/extensions/ui#peakProtocol +#define LV2_UI__resize LV2_UI_PREFIX "resize" ///< http://lv2plug.in/ns/extensions/ui#resize +#define LV2_UI__showInterface LV2_UI_PREFIX "showInterface" ///< http://lv2plug.in/ns/extensions/ui#showInterface +#define LV2_UI__touch LV2_UI_PREFIX "touch" ///< http://lv2plug.in/ns/extensions/ui#touch +#define LV2_UI__ui LV2_UI_PREFIX "ui" ///< http://lv2plug.in/ns/extensions/ui#ui +#define LV2_UI__updateRate LV2_UI_PREFIX "updateRate" ///< http://lv2plug.in/ns/extensions/ui#updateRate +#define LV2_UI__windowTitle LV2_UI_PREFIX "windowTitle" ///< http://lv2plug.in/ns/extensions/ui#windowTitle + +/** + The index returned by LV2UI_Port_Map::port_index() for unknown ports. +*/ +#define LV2UI_INVALID_PORT_INDEX ((uint32_t)-1) + +#ifdef __cplusplus +extern "C" { +#endif + +/** + A pointer to some widget or other type of UI handle. + + The actual type is defined by the type of the UI. +*/ +typedef void* LV2UI_Widget; + +/** + A pointer to UI instance internals. + + The host may compare this to NULL, but otherwise MUST NOT interpret it. +*/ +typedef void* LV2UI_Handle; + +/** + A pointer to a controller provided by the host. + + The UI may compare this to NULL, but otherwise MUST NOT interpret it. +*/ +typedef void* LV2UI_Controller; + +/** + A pointer to opaque data for a feature. +*/ +typedef void* LV2UI_Feature_Handle; + +/** + A host-provided function that sends data to a plugin's input ports. + + @param controller The opaque controller pointer passed to + LV2UI_Descriptor::instantiate(). + + @param port_index Index of the port to update. + + @param buffer Buffer containing `buffer_size` bytes of data. + + @param buffer_size Size of `buffer` in bytes. + + @param port_protocol Either 0 or the URID for a ui:PortProtocol. If 0, the + protocol is implicitly ui:floatProtocol, the port MUST be an lv2:ControlPort + input, `buffer` MUST point to a single float value, and `buffer_size` MUST + be sizeof(float). The UI SHOULD NOT use a protocol not supported by the + host, but the host MUST gracefully ignore any protocol it does not + understand. +*/ +typedef void (*LV2UI_Write_Function)(LV2UI_Controller controller, + uint32_t port_index, + uint32_t buffer_size, + uint32_t port_protocol, + const void* buffer); + +/** + A plugin UI. + + A pointer to an object of this type is returned by the lv2ui_descriptor() + function. +*/ +typedef struct _LV2UI_Descriptor { + /** + The URI for this UI (not for the plugin it controls). + */ + const char* URI; + + /** + Create a new UI and return a handle to it. This function works + similarly to LV2_Descriptor::instantiate(). + + @param descriptor The descriptor for the UI to instantiate. + + @param plugin_uri The URI of the plugin that this UI will control. + + @param bundle_path The path to the bundle containing this UI, including + the trailing directory separator. + + @param write_function A function that the UI can use to send data to the + plugin's input ports. + + @param controller A handle for the UI instance to be passed as the + first parameter of UI methods. + + @param widget (output) widget pointer. The UI points this at its main + widget, which has the type defined by the UI type in the data file. + + @param features An array of LV2_Feature pointers. The host must pass + all feature URIs that it and the UI supports and any additional data, as + in LV2_Descriptor::instantiate(). Note that UI features and plugin + features are not necessarily the same. + + */ + LV2UI_Handle (*instantiate)(const struct _LV2UI_Descriptor* descriptor, + const char* plugin_uri, + const char* bundle_path, + LV2UI_Write_Function write_function, + LV2UI_Controller controller, + LV2UI_Widget* widget, + const LV2_Feature* const* features); + + + /** + Destroy the UI. The host must not try to access the widget after + calling this function. + */ + void (*cleanup)(LV2UI_Handle ui); + + /** + Tell the UI that something interesting has happened at a plugin port. + + What is "interesting" and how it is written to `buffer` is defined by + `format`, which has the same meaning as in LV2UI_Write_Function(). + Format 0 is a special case for lv2:ControlPort, where this function + should be called when the port value changes (but not necessarily for + every change), `buffer_size` must be sizeof(float), and `buffer` + points to a single IEEE-754 float. + + By default, the host should only call this function for lv2:ControlPort + inputs. However, the UI can request updates for other ports statically + with ui:portNotification or dynamicaly with ui:portSubscribe. + + The UI MUST NOT retain any reference to `buffer` after this function + returns, it is only valid for the duration of the call. + + This member may be NULL if the UI is not interested in any port events. + */ + void (*port_event)(LV2UI_Handle ui, + uint32_t port_index, + uint32_t buffer_size, + uint32_t format, + const void* buffer); + + /** + Return a data structure associated with an extension URI, typically an + interface struct with additional function pointers + + This member may be set to NULL if the UI is not interested in supporting + any extensions. This is similar to LV2_Descriptor::extension_data(). + + */ + const void* (*extension_data)(const char* uri); +} LV2UI_Descriptor; + +/** + Feature/interface for resizable UIs (LV2_UI__resize). + + This structure is used in two ways: as a feature passed by the host via + LV2UI_Descriptor::instantiate(), or as an interface provided by a UI via + LV2UI_Descriptor::extension_data()). +*/ +typedef struct _LV2UI_Resize { + /** + Pointer to opaque data which must be passed to ui_resize(). + */ + LV2UI_Feature_Handle handle; + + /** + Request/advertise a size change. + + When provided by the host, the UI may call this function to inform the + host about the size of the UI. + + When provided by the UI, the host may call this function to notify the + UI that it should change its size accordingly. In this case, the host + must pass the LV2UI_Handle to provide access to the UI instance. + + @return 0 on success. + */ + int (*ui_resize)(LV2UI_Feature_Handle handle, int width, int height); +} LV2UI_Resize; + +/** + Feature to map port symbols to UIs. + + This can be used by the UI to get the index for a port with the given + symbol. This makes it possible to implement and distribute a UI separately + from the plugin (since symbol, unlike index, is a stable port identifier). +*/ +typedef struct _LV2UI_Port_Map { + /** + Pointer to opaque data which must be passed to port_index(). + */ + LV2UI_Feature_Handle handle; + + /** + Get the index for the port with the given `symbol`. + + @return The index of the port, or LV2UI_INVALID_PORT_INDEX if no such + port is found. + */ + uint32_t (*port_index)(LV2UI_Feature_Handle handle, const char* symbol); +} LV2UI_Port_Map; + +/** + Feature to subscribe to port updates (LV2_UI__portSubscribe). +*/ +typedef struct _LV2UI_Port_Subscribe { + /** + Pointer to opaque data which must be passed to subscribe() and + unsubscribe(). + */ + LV2UI_Feature_Handle handle; + + /** + Subscribe to updates for a port. + + This means that the host will call the UI's port_event() function when + the port value changes (as defined by protocol). + + Calling this function with the same `port_index` and `port_protocol` + as an already active subscription has no effect. + + @param handle The handle field of this struct. + @param port_index The index of the port. + @param port_protocol The URID of the ui:PortProtocol. + @param features Features for this subscription. + @return 0 on success. + */ + uint32_t (*subscribe)(LV2UI_Feature_Handle handle, + uint32_t port_index, + uint32_t port_protocol, + const LV2_Feature* const* features); + + /** + Unsubscribe from updates for a port. + + This means that the host will cease calling calling port_event() when + the port value changes. + + Calling this function with a `port_index` and `port_protocol` that + does not refer to an active port subscription has no effect. + + @param handle The handle field of this struct. + @param port_index The index of the port. + @param port_protocol The URID of the ui:PortProtocol. + @param features Features for this subscription. + @return 0 on success. + */ + uint32_t (*unsubscribe)(LV2UI_Feature_Handle handle, + uint32_t port_index, + uint32_t port_protocol, + const LV2_Feature* const* features); +} LV2UI_Port_Subscribe; + +/** + A feature to notify the host that the user has grabbed a UI control. +*/ +typedef struct _LV2UI_Touch { + /** + Pointer to opaque data which must be passed to ui_resize(). + */ + LV2UI_Feature_Handle handle; + + /** + Notify the host that a control has been grabbed or released. + + The host should cease automating the port or otherwise manipulating the + port value until the control has been ungrabbed. + + @param handle The handle field of this struct. + @param port_index The index of the port associated with the control. + @param grabbed If true, the control has been grabbed, otherwise the + control has been released. + */ + void (*touch)(LV2UI_Feature_Handle handle, + uint32_t port_index, + bool grabbed); +} LV2UI_Touch; + +/** + UI Idle Interface (LV2_UI__idleInterface) + + UIs can provide this interface to have an idle() callback called by the host + rapidly to update the UI. +*/ +typedef struct _LV2UI_Idle_Interface { + /** + Run a single iteration of the UI's idle loop. + + This will be called rapidly in the UI thread at a rate appropriate + for a toolkit main loop. There are no precise timing guarantees, but + the host should attempt to call idle() at a high enough rate for smooth + animation, at least 30Hz. + + @return non-zero if the UI has been closed, in which case the host + should stop calling idle(), and can either completely destroy the UI, or + re-show it and resume calling idle(). + */ + int (*idle)(LV2UI_Handle ui); +} LV2UI_Idle_Interface; + +/** + UI Show Interface (LV2_UI__showInterface) + + UIs can provide this interface to show and hide a window, which allows them + to function in hosts unable to embed their widget. This allows any UI to + provide a fallback for embedding that works in any host. + + If used: + - The host MUST use LV2UI_Idle_Interface to drive the UI. + - The UI MUST return non-zero from LV2UI_Idle_Interface::idle() when it has been closed. + - If idle() returns non-zero, the host MUST call hide() and stop calling + idle(). It MAY later call show() then resume calling idle(). +*/ +typedef struct _LV2UI_Show_Interface { + /** + Show a window for this UI. + + The window title MAY have been passed by the host to + LV2UI_Descriptor::instantiate() as an LV2_Options_Option with key + LV2_UI__windowTitle. + + @return 0 on success, or anything else to stop being called. + */ + int (*show)(LV2UI_Handle ui); + + /** + Hide the window for this UI. + + @return 0 on success, or anything else to stop being called. + */ + int (*hide)(LV2UI_Handle ui); +} LV2UI_Show_Interface; + +/** + Peak data for a slice of time, the update format for ui:peakProtocol. +*/ +typedef struct _LV2UI_Peak_Data { + /** + The start of the measurement period. This is just a running counter + that is only meaningful in comparison to previous values and must not be + interpreted as an absolute time. + */ + uint32_t period_start; + + /** + The size of the measurement period, in the same units as period_start. + */ + uint32_t period_size; + + /** + The peak value for the measurement period. This should be the maximal + value for abs(sample) over all the samples in the period. + */ + float peak; +} LV2UI_Peak_Data; + +/** + Prototype for UI accessor function. + + This is the entry point to a UI library, which works in the same way as + lv2_descriptor() but for UIs rather than plugins. +*/ +LV2_SYMBOL_EXPORT +const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index); + +/** + The type of the lv2ui_descriptor() function. +*/ +typedef const LV2UI_Descriptor* (*LV2UI_DescriptorFunction)(uint32_t index); + +#ifdef __cplusplus +} +#endif + +#endif /* LV2_UI_H */ + +/** + @} +*/ diff --git a/lv2/ui/ui.ttl b/lv2/ui/ui.ttl new file mode 100644 index 0000000..48ac166 --- /dev/null +++ b/lv2/ui/ui.ttl @@ -0,0 +1,461 @@ +@prefix lv2: <http://lv2plug.in/ns/lv2core#> . +@prefix owl: <http://www.w3.org/2002/07/owl#> . +@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . +@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . +@prefix ui: <http://lv2plug.in/ns/extensions/ui#> . +@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . + +<http://lv2plug.in/ns/extensions/ui> + a owl:Ontology ; + owl:imports <http://lv2plug.in/ns/lv2core> ; + rdfs:seeAlso <ui.h> , + <lv2-ui.doap.ttl> ; + lv2:documentation """ +<p>This extension is used to create User Interfaces (UIs) for LV2 plugins.</p> + +<p>UIs are implemented as an LV2UI_Descriptor loaded via lv2ui_descriptor() in +a shared library, and are distributed in bundles just like plugins.</p> + +<p>UIs are associated with plugins in data:</p> + +<pre class="turtle-code"> +@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> . +</pre> + +<p>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.</p> + +<p>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.</p> + +<p>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.</p> + +<p>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).</p> + +<p>UI functionality may be extended via features, much like plugins:</p> + +<pre class="turtle-code"> +<http://my.pluginui> lv2:requiredFeature <http://my.feature> . +<http://my.pluginui> lv2:optionalFeature <http://my.feature> . +</pre> + +<p>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.</p> + +<p>UIs written to this specification do not need to be thread-safe. All +functions may only be called in the <q>UI thread</q>. There is only one UI +thread (for toolkits, the one the UI main loop runs in). There is no +requirement that a <q>UI</q> actually be a graphical widget.</p> + +<p>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.</p> +""" . + +ui:UI + a rdfs:Class , + owl:Class ; + rdfs:label "User Interface" ; + rdfs:comment "A UI for an LV2 plugin" . + +ui:GtkUI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "GTK2 UI" ; + rdfs: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.""" . + +ui:Gtk3UI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "GTK3 UI" ; + rdfs:comment """A UI where the LV2_Widget is a pointer to a Gtk+ 3.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.""" . + +ui:Qt4UI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "Qt4 UI" ; + rdfs: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.""" . + +ui:Qt5UI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "Qt5 UI" ; + rdfs:comment """A UI where the LV2_Widget is a pointer to a Qt5 compatible QWidget, and the host guarantees that the Qt5 library has been initialised and the Qt5 main loop is running before a UI of this type is instantiated.""" . + +ui:X11UI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "X11 UI" ; + rdfs: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. This is the native UI type on most POSIX systems.""" . + +ui:WindowsUI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "Windows UI" ; + rdfs:comment """A UI where the LV2_Widget is a Windows HWND window ID. Note this is actually an unsigned 32-bit integer, i.e. the LV2_Widget is not a pointer to a HWND but should be interpreted as an HWND itself. This is the native UI type on Microsoft Windows.""" . + +ui:CocoaUI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "Cocoa UI" ; + rdfs:comment """A UI where the LV2_Widget is a pointer to a NSView, the basic view type for the Cocoa API (formerly OpenStep). This is the native UI type on Mac OS X.""" . + +ui:ui + a rdf:Property ; + rdfs:domain lv2:Plugin ; + rdfs:range ui:UI ; + rdfs:label "user interface" ; + rdfs:comment """Relates a plugin to a UI that applies to it.""" . + +ui:binary + a rdf:Property ; + owl:sameAs lv2:binary ; + owl:deprecated "true"^^xsd:boolean ; + rdfs:label "binary" ; + rdfs:comment """The shared library a UI resides in. This property is redundant, new UIs SHOULD use lv2:binary, however hosts MUST still support ui:binary at this time.""" . + +ui:makeSONameResident + a lv2:Feature ; + owl:deprecated "true"^^xsd:boolean ; + lv2:documentation """ +<p>DEPRECATED</p> + +<p>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. <code>gcc -Wl,-z,nodelete</code>.</p> +""" . + +ui:noUserResize + a lv2:Feature ; + lv2:documentation """ +<p>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.</p> +""" . + +ui:fixedSize + a lv2:Feature ; + lv2:documentation """ +<p>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.</p> +""" . + +ui:parent + a lv2:Feature ; + lv2:documentation """ +<p>The parent for the UI.</p> + +<p>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.</p> +""" . + +ui:PortNotification + a rdfs:Class , + owl:Class ; + rdfs:subClassOf [ + a owl:Restriction ; + owl:onProperty ui:plugin ; + owl:cardinality 1 ; + rdfs:comment "A PortNotification MUST have exactly one ui:plugin." ; + ] ; + lv2:documentation """ +<p>A port notification. This describes which ports the host must send +notifications to the UI about. The port can be specific by index, using the +ui:portIndex property, or symbol, using the lv2:symbol property. Since port +indices are not guaranteed to be stable between different revisions (or even +instantiations) of a plugin, symbol is recommended, and index may only be used +by UIs shipped in the same bundle as the plugin.</p> + +<p>A ui:PortNotification MUST have either a ui:portIndex or a lv2:symbol to +indicate which port it refers to.</p> +""" . + +ui:portNotification + a rdf:Property , + owl:ObjectProperty ; + rdfs:domain ui:UI ; + rdfs:range ui:PortNotification ; + rdfs:label "port notification" ; + lv2:documentation """ +<p>Indicates that a UI should receive notification (via +LV2UI_Descriptor::port_event()) when a particular port's value changes.</p> + +<p>For example:</p> +<pre class="turtle-code"> +eg:ui + a ui:GtkUI ; + ui:portNotification [ + ui:plugin eg:plugin ; + lv2:symbol "gain" ; + ui:protocol ui:floatProtocol + ] . +</pre> +""" . + +ui:plugin + a rdf:Property , + owl:ObjectProperty ; + rdfs:domain ui:PortNotification ; + rdfs:range lv2:Plugin ; + rdfs:label "plugin" ; + rdfs:comment "The plugin a portNotification applies to." . + +ui:portIndex + a rdf:Property , + owl:DatatypeProperty ; + rdfs:domain ui:PortNotification ; + rdfs:range xsd:decimal ; + rdfs:label "port index" ; + rdfs:comment "The index of the port a portNotification applies to." . + +ui:notifyType + a rdf:Property ; + rdfs:domain ui:PortNotification ; + rdfs:label "notify type" ; + lv2:documentation """ +<p>Indicates a particular type that the UI should be notified of. In the case +of ports where several types of data can be present (e.g. event ports), this +can be used to indicate that only a particular type of data should cause +notification. This is useful where port traffic is very dense, but only a +certain small number of events are actually of interest to the UI.</p> +""" . + +ui:resize + a lv2:Feature , + lv2:ExtensionData ; + lv2:documentation """ +<p>A feature that allows the UI to notify the host about its current size, or +request a size change. 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.</p> +""" . + +ui:portMap + a lv2:Feature ; + lv2:documentation """ +<p>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.</p> +""" . + +ui:portSubscribe + a lv2:Feature ; + lv2:documentation """ +<p>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.</p> +""" . + +ui:touch + a lv2:Feature ; + lv2:documentation """ +<p>A feature to notify the host that the user has grabbed a particular 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 morotised 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.</p> +""" . + +ui:idleInterface + a lv2:Feature , + lv2:ExtensionData ; + lv2:documentation """ +<p>A feature that provides a callback for the host to call rapidly 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.</p> + +<p>To indicate support, the host should pass a feature to instantiate() with +this URI, with NULL for data.</p> +""" . + +ui:showInterface + a lv2:ExtensionData ; + lv2:documentation """ +<p>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.</p> +""" . + +ui:windowTitle + a rdf:Property ; + rdfs:range xsd:string ; + rdfs:label "window title" ; + rdfs:comment "The title for the window shown by LV2UI_Show_Interface." . + +ui:updateRate + a rdf:Property ; + rdfs:range xsd:float ; + rdfs:label "update rate" ; + rdfs:comment "The target rate, in Hz, to send updates to the UI." . + +ui:protocol + a rdf:Property ; + rdfs:domain ui:PortNotification ; + rdfs:range ui:PortProtocol ; + rdfs:label "protocol" ; + rdfs:comment "The protocol to be used for this notification." . + +ui:PortProtocol + a rdfs:Class ; + rdfs:subClassOf lv2:Feature ; + rdfs:label "Port Protocol" ; + lv2:documentation """ +<p>A PortProtocol defines a method to communicate port data between a UI and +plugin.</p> + +<p>Any PortProtocol MUST define:</p> +<table> +<tr><th>Port Type</th> + <td>Which plugin port types the buffer type is valid for.</td></tr> +<tr><th>Feature Data</th> + <td>What data (if any) should be passed in the LV2_Feature.</td></tr> +</table> + +<p>Any PortProtocol for an output port MUST define:</p> +<table> +<tr><th>Update Frequency</th> + <td>When the host should call port_event().</td></tr> +<tr><th>Update Format</th> + <td>The format of the data in the buffer passed to port_event().</td></tr> +<tr><th>Options</th> + <td>The format of the options passed to subscribe() and unsubscribe().</td> +</tr></table> + +<p>Any PortProtocol for an input port MUST define:</p> +<table> +<tr><th>Write Format</th> + <td>The format of the data in the buffer passed to write_port().</td></tr> +<tr><th>Write Effect</th> + <td>What happens when the UI calls write_port().</td></tr> +</table> + +<p>For an example, see ui:floatProtocol or ui:peakProtocol. +</p> + +<p>PortProtocol is a subclass of lv2:Feature, so UIs use lv2:optionalFeature and +lv2:requiredFeature to specify which PortProtocols they want to use. +</p> +""" . + +ui:floatProtocol + a ui:PortProtocol ; + rdfs:label "floating point value" ; + lv2:documentation """ + +<p>A protocol for transferring single floating point values. The rules for +this protocol are:</p> +<table> +<tr><th>Port Type</th> + <td>lv2:ControlPort</td></tr> +<tr><th>Feature Data</th> + <td>None.</td></tr> +<tr><th>Update Frequency</th> + <td>The host SHOULD call port_event() as soon as possible when the port + value has changed, but there are no timing guarantees.</td></tr> +<tr><th>Update Format</th> + <td>A single <code>float</code>.</td></tr> +<tr><th>Options</th> + <td>None.</td></tr> +<tr><th>Write Format</th> + <td>A single <code>float</code>.</td></tr> +<tr><th>Write Effect</th> + <td>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.</td></tr> +</table> +""" . + +ui:peakProtocol + a ui:PortProtocol ; + rdfs:label "peak measurement for a period of audio" ; + lv2:documentation """ +<p>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, e.g. an animated meter widget that shows +the level of the audio input or output.</p> + +<p>A contiguous sequence of audio samples for which a peak value has been +computed is called a <em>measurement period</em>.</p> + +<p>The rules for this protocol are:</p> +<table> +<tr><th>Port Type</th> + <td>lv2:AudioPort</td></tr> +<tr><th>Feature Data</th> + <td>None.</td></tr> +<tr><th>Update Frequency</th> + <td>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.</td></tr> +<tr><th>Update Format</th> + <td>A single LV2UI_Peak_Data object.</td></tr> +<tr><th>Options</th> + <td>None.</td></tr> +<tr><th>Write Format</th> + <td>None.</td></tr> +<tr><th>Write Effect</th> + <td>None.</td></tr> +</table> +""" . |