diff options
Diffstat (limited to 'lv2/ui')
| -rw-r--r-- | lv2/ui/manifest.ttl | 9 | ||||
| -rw-r--r-- | lv2/ui/ui.h | 539 | ||||
| -rw-r--r-- | lv2/ui/ui.meta.ttl | 627 | ||||
| -rw-r--r-- | lv2/ui/ui.ttl | 248 |
4 files changed, 1423 insertions, 0 deletions
diff --git a/lv2/ui/manifest.ttl b/lv2/ui/manifest.ttl new file mode 100644 index 0000000..9f259ad --- /dev/null +++ b/lv2/ui/manifest.ttl @@ -0,0 +1,9 @@ +@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 22 ; + rdfs:seeAlso <ui.ttl> . + diff --git a/lv2/ui/ui.h b/lv2/ui/ui.h new file mode 100644 index 0000000..ce6aa4f --- /dev/null +++ b/lv2/ui/ui.h @@ -0,0 +1,539 @@ +/* + 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 + @ingroup lv2 + + 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 "lv2/urid/urid.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__requestValue LV2_UI_PREFIX "requestValue" ///< http://lv2plug.in/ns/extensions/ui#requestValue +#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 +#define LV2_UI__scaleFactor LV2_UI_PREFIX "scaleFactor" ///< http://lv2plug.in/ns/extensions/ui#scaleFactor +#define LV2_UI__foregroundColor LV2_UI_PREFIX "foregroundColor" ///< http://lv2plug.in/ns/extensions/ui#foregroundColor +#define LV2_UI__backgroundColor LV2_UI_PREFIX "backgroundColor" ///< http://lv2plug.in/ns/extensions/ui#backgroundColor + +/** + 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 { + /** + 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 { + /** + 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 { + /** + 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 { + /** + 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; + +/** + A status code for LV2UI_Request_Value::request(). +*/ +typedef enum { + /** + Completed successfully. + + The host will set the parameter later if the user choses a new value. + */ + LV2UI_REQUEST_VALUE_SUCCESS, + + /** + Parameter already being requested. + + The host is already requesting a parameter from the user (for example, a + dialog is visible), or the UI is otherwise busy and can not make this + request. + */ + LV2UI_REQUEST_VALUE_BUSY, + + /** + Unknown parameter. + + The host is not aware of this parameter, and is not able to set a new + value for it. + */ + LV2UI_REQUEST_VALUE_ERR_UNKNOWN, + + /** + Unsupported parameter. + + The host knows about this parameter, but does not support requesting a + new value for it from the user. This is likely because the host does + not have UI support for choosing a value with the appropriate type. + */ + LV2UI_REQUEST_VALUE_ERR_UNSUPPORTED +} LV2UI_Request_Value_Status; + +/** + A feature to request a new parameter value from the host. +*/ +typedef struct { + /** + Pointer to opaque data which must be passed to request(). + */ + LV2UI_Feature_Handle handle; + + /** + Request a value for a parameter from the host. + + This is mainly used by UIs to request values for complex parameters that + don't change often, such as file paths, but it may be used to request + any parameter value. + + This function returns immediately, and the return value indicates + whether the host can fulfill the request. The host may notify the + plugin about the new parameter value, for example when a file is + selected by the user, via the usual mechanism. Typically, the host will + send a message to the plugin that sets the new parameter value, and the + plugin will notify the UI via a message as usual for any other parameter + change. + + To provide an appropriate UI, the host can determine details about the + parameter from the plugin data as usual. The additional parameters of + this function provide support for more advanced use cases, but in the + simple common case, the plugin will simply pass the key of the desired + parameter and zero for everything else. + + @param handle The handle field of this struct. + + @param key The URID of the parameter. + + @param type The optional type of the value to request. This can be used + to request a specific value type for parameters that support several. + If non-zero, it must be the URID of an instance of rdfs:Class or + rdfs:Datatype. + + @param features Additional features for this request, or NULL. + + @return A status code which is 0 on success. + */ + LV2UI_Request_Value_Status (*request)(LV2UI_Feature_Handle handle, + LV2_URID key, + LV2_URID type, + const LV2_Feature* const* features); + +} LV2UI_Request_Value; + +/** + 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 { + /** + 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 { + /** + 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 { + /** + 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.meta.ttl b/lv2/ui/ui.meta.ttl new file mode 100644 index 0000000..cb92a86 --- /dev/null +++ b/lv2/ui/ui.meta.ttl @@ -0,0 +1,627 @@ +@prefix dcs: <http://ontologi.es/doap-changeset#> . +@prefix doap: <http://usefulinc.com/ns/doap#> . +@prefix foaf: <http://xmlns.com/foaf/0.1/> . +@prefix lv2: <http://lv2plug.in/ns/lv2core#> . +@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#> . + +<http://lv2plug.in/ns/extensions/ui> + a doap:Project ; + doap:license <http://opensource.org/licenses/isc> ; + doap:name "LV2 UI" ; + doap:shortdesc "User interfaces for LV2 plugins." ; + 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.22" ; + doap:created "2020-04-26" ; + doap:file-release <http://lv2plug.in/spec/lv2-1.18.0.tar.bz2> ; + dcs:blame <http://drobilla.net/drobilla#me> ; + dcs:changeset [ + dcs:item [ + rdfs:label "Add ui:requestValue feature." + ] , [ + rdfs:label "Add ui:scaleFactor, ui:foregroundColor, and ui:backgroundColor properties." + ] , [ + rdfs:label "Deprecate ui:binary." + ] + ] + ] , [ + 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." + ] + ] + ] ; + lv2:documentation """ + +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: + + :::turtle + @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 (`ui: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: + + :::turtle + <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 <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. + +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. + +"""^^lv2:Markdown . + +ui:GtkUI + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:Gtk3UI + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:Qt4UI + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:Qt5UI + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:X11UI + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:WindowsUI + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:CocoaUI + lv2:documentation """ + +This is the native UI type on Mac OS X. + +"""^^lv2:Markdown . + +ui:binary + lv2:documentation """ + +This property is redundant and deprecated: new UIs should use lv2:binary +instead, however hosts must still support ui:binary. + +"""^^lv2:Markdown . + +ui:makeSONameResident + lv2:documentation """ + +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`. + +"""^^lv2:Markdown . + +ui:noUserResize + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:fixedSize + lv2:documentation """ + +If a UI has this feature, it indicates the same thing as ui: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. + +"""^^lv2:Markdown . + +ui:scaleFactor + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:backgroundColor + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:foregroundColor + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:parent + lv2:documentation """ + +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 ui: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. + +"""^^lv2:Markdown . + +ui:PortNotification + lv2:documentation """ + +This describes which ports the host must send notifications to the UI about. +The port must be specific either by index, using the ui: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. + +"""^^lv2:Markdown . + +ui:portNotification + lv2:documentation """ + +Specifies that a UI should receive notifications about changes to a particular +port's value via LV2UI_Descriptor::port_event(). + +For example: + + :::turtle + eg:ui + a ui:X11UI ; + ui:portNotification [ + ui:plugin eg:plugin ; + lv2:symbol "gain" ; + ui:protocol ui:floatProtocol + ] . + +"""^^lv2:Markdown . + +ui:notifyType + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:resize + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:portMap + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:portSubscribe + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:touch + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:requestValue + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:idleInterface + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:showInterface + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + +ui:PortProtocol + lv2:documentation """ + +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 ui:floatProtocol or ui:peakProtocol. + +PortProtocol is a subclass of lv2:Feature, so UIs use lv2:optionalFeature and +lv2:requiredFeature to specify which PortProtocols they want to use. + +"""^^lv2:Markdown . + +ui:floatProtocol + lv2:documentation """ + +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 <code>float</code>. + +Options +: None. + +Write Format +: A single <code>float</code>. + +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. + +"""^^lv2:Markdown . + +ui:peakProtocol + lv2:documentation """ + +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. + +"""^^lv2:Markdown . + diff --git a/lv2/ui/ui.ttl b/lv2/ui/ui.ttl new file mode 100644 index 0000000..61f8bca --- /dev/null +++ b/lv2/ui/ui.ttl @@ -0,0 +1,248 @@ +@prefix lv2: <http://lv2plug.in/ns/lv2core#> . +@prefix opts: <http://lv2plug.in/ns/ext/options#> . +@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 ; + rdfs:label "LV2 UI" ; + rdfs:comment "User interfaces for LV2 plugins." ; + owl:imports <http://lv2plug.in/ns/lv2core> ; + rdfs:seeAlso <ui.h> , + <ui.meta.ttl> . + +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 widget is a pointer to a Gtk+ 2.0 GtkWidget." . + +ui:Gtk3UI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "GTK3 UI" ; + rdfs:comment "A UI where the widget is a pointer to a Gtk+ 3.0 GtkWidget." . + +ui:Qt4UI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "Qt4 UI" ; + rdfs:comment "A UI where the widget is a pointer to a Qt4 QWidget." . + +ui:Qt5UI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "Qt5 UI" ; + rdfs:comment "A UI where the widget is a pointer to a Qt5 QWidget." . + +ui:X11UI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "X11 UI" ; + rdfs:comment "A UI where the widget is an X11 Window window ID." . + +ui:WindowsUI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "Windows UI" ; + rdfs:comment "A UI where the widget is a Windows HWND window ID." . + +ui:CocoaUI + a rdfs:Class , + owl:Class ; + rdfs:subClassOf ui:UI ; + rdfs:label "Cocoa UI" ; + rdfs:comment "A UI where the widget is a pointer to a NSView." . + +ui:ui + a rdf:Property , + owl:ObjectProperty ; + 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:ObjectProperty ; + owl:sameAs lv2:binary ; + owl:deprecated "true"^^xsd:boolean ; + rdfs:label "binary" ; + rdfs:comment "The shared library that a UI resides in." . + +ui:makeSONameResident + a lv2:Feature ; + owl:deprecated "true"^^xsd:boolean ; + rdfs:label "make SO name resident" ; + rdfs:comment "UI binary must not be unloaded." . + +ui:noUserResize + a lv2:Feature ; + rdfs:label "no user resize" ; + rdfs:comment "Non-resizable UI." . + +ui:fixedSize + a lv2:Feature ; + rdfs:label "fixed size" ; + rdfs:comment "Non-resizable UI that will never resize itself." . + +ui:scaleFactor + a rdf:Property , + owl:DatatypeProperty , + opts:Option ; + rdfs:range xsd:float ; + rdfs:label "scale factor" ; + rdfs:comment "Scale factor for high resolution screens." . + +ui:backgroundColor + a rdf:Property , + owl:DatatypeProperty , + opts:Option ; + rdfs:label "background color" ; + rdfs:comment """The background color of the host's UI.""" . + +ui:foregroundColor + a rdf:Property , + owl:DatatypeProperty , + opts:Option ; + rdfs:label "foreground color" ; + rdfs:comment """The foreground color of the host's UI.""" . + +ui:parent + a lv2:Feature ; + rdfs:label "parent" ; + rdfs:comment "The parent for a UI." . + +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." + ] ; + rdfs:label "Port Notification" ; + rdfs:comment "A description of port updates that a host must send a UI." . + +ui:portNotification + a rdf:Property , + owl:ObjectProperty ; + rdfs:domain ui:UI ; + rdfs:range ui:PortNotification ; + rdfs:label "port notification" ; + rdfs:comment "Specifies a port notification that is required by a UI." . + +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 , + owl:ObjectProperty ; + rdfs:domain ui:PortNotification ; + rdfs:label "notify type" ; + rdfs:comment "A particular type that the UI should be notified of." . + +ui:resize + a lv2:Feature , + lv2:ExtensionData ; + rdfs:label "resize" ; + rdfs:comment """A feature that control of, and notifications about, a UI's size.""" . + +ui:portMap + a lv2:Feature ; + rdfs:label "port map" ; + rdfs:comment "A feature for accessing the index of a port by symbol." . + +ui:portSubscribe + a lv2:Feature ; + rdfs:label "port subscribe" ; + rdfs:comment "A feature for dynamically subscribing to updates from a port." . + +ui:touch + a lv2:Feature ; + rdfs:label "touch" ; + rdfs:comment "A feature to notify that the user has grabbed a port control." . + +ui:requestValue + a lv2:Feature ; + rdfs:label "request value" ; + rdfs:comment "A feature to request a parameter value from the user via the host." . + +ui:idleInterface + a lv2:Feature , + lv2:ExtensionData ; + rdfs:label "idle interface" ; + rdfs:comment "A feature that provides a callback for the host to drive the UI." . + +ui:showInterface + a lv2:ExtensionData ; + rdfs:label "show interface" ; + rdfs:comment "An interface for showing and hiding a window for a UI." . + +ui:windowTitle + a rdf:Property , + owl:DatatypeProperty ; + 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 , + owl:DatatypeProperty ; + 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 , + owl:ObjectProperty ; + 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" ; + rdfs:comment "A method to communicate port data between a UI and plugin." . + +ui:floatProtocol + a ui:PortProtocol ; + rdfs:label "float protocol" ; + rdfs:comment "A protocol for transferring single floating point values." . + +ui:peakProtocol + a ui:PortProtocol ; + rdfs:label "peak protocol" ; + rdfs:comment "A protocol for sending continuous peak measurements of an audio signal." . + |