lilv.h

Go to the documentation of this file.

/*
  Copyright 2007-2016 David Robillard <http://drobilla.net>
 
  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.
*/

 
#ifndef LILV_LILV_H
#define LILV_LILV_H
 
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
 
#include "lv2/lv2.h"
#include "lv2/state.h"
#include "lv2/urid.h"
 
#ifdef LILV_SHARED
#    ifdef _WIN32
#        define LILV_LIB_IMPORT __declspec(dllimport)
#        define LILV_LIB_EXPORT __declspec(dllexport)
#    else
#        define LILV_LIB_IMPORT __attribute__((visibility("default")))
#        define LILV_LIB_EXPORT __attribute__((visibility("default")))
#    endif
#    ifdef LILV_INTERNAL
#        define LILV_API LILV_LIB_EXPORT
#    else
#        define LILV_API LILV_LIB_IMPORT
#    endif
#else
#    define LILV_API
#endif
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
#    define LILV_DEPRECATED __attribute__((__deprecated__))
#else
#    define LILV_DEPRECATED
#endif
 
#ifdef __cplusplus
extern "C" {
#else
#   include <stdbool.h>
#endif
 
#define LILV_NS_DOAP "http://usefulinc.com/ns/doap#"
#define LILV_NS_FOAF "http://xmlns.com/foaf/0.1/"
#define LILV_NS_LILV "http://drobilla.net/ns/lilv#"
#define LILV_NS_LV2  "http://lv2plug.in/ns/lv2core#"
#define LILV_NS_OWL  "http://www.w3.org/2002/07/owl#"
#define LILV_NS_RDF  "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
#define LILV_NS_RDFS "http://www.w3.org/2000/01/rdf-schema#"
#define LILV_NS_XSD  "http://www.w3.org/2001/XMLSchema#"
 
#define LILV_URI_ATOM_PORT    "http://lv2plug.in/ns/ext/atom#AtomPort"
#define LILV_URI_AUDIO_PORT   "http://lv2plug.in/ns/lv2core#AudioPort"
#define LILV_URI_CONTROL_PORT "http://lv2plug.in/ns/lv2core#ControlPort"
#define LILV_URI_CV_PORT      "http://lv2plug.in/ns/lv2core#CVPort"
#define LILV_URI_EVENT_PORT   "http://lv2plug.in/ns/ext/event#EventPort"
#define LILV_URI_INPUT_PORT   "http://lv2plug.in/ns/lv2core#InputPort"
#define LILV_URI_MIDI_EVENT   "http://lv2plug.in/ns/ext/midi#MidiEvent"
#define LILV_URI_OUTPUT_PORT  "http://lv2plug.in/ns/lv2core#OutputPort"
#define LILV_URI_PORT         "http://lv2plug.in/ns/lv2core#Port"
 
typedef struct LilvPluginImpl      LilvPlugin;       
typedef struct LilvPluginClassImpl LilvPluginClass;  
typedef struct LilvPortImpl        LilvPort;         
typedef struct LilvScalePointImpl  LilvScalePoint;   
typedef struct LilvUIImpl          LilvUI;           
typedef struct LilvNodeImpl        LilvNode;         
typedef struct LilvWorldImpl       LilvWorld;        
typedef struct LilvInstanceImpl    LilvInstance;     
typedef struct LilvStateImpl       LilvState;        
 
typedef void LilvIter;           
typedef void LilvPluginClasses;  
typedef void LilvPlugins;        
typedef void LilvScalePoints;    
typedef void LilvUIs;            
typedef void LilvNodes;          


LILV_API void
lilv_free(void* ptr);


LILV_API LILV_DEPRECATED const char*
lilv_uri_to_path(const char* uri);

LILV_API char*
lilv_file_uri_parse(const char* uri, char** hostname);

LILV_API LilvNode*
lilv_new_uri(LilvWorld* world, const char* uri);

LILV_API LilvNode*
lilv_new_file_uri(LilvWorld* world, const char* host, const char* path);

LILV_API LilvNode*
lilv_new_string(LilvWorld* world, const char* str);

LILV_API LilvNode*
lilv_new_int(LilvWorld* world, int val);

LILV_API LilvNode*
lilv_new_float(LilvWorld* world, float val);

LILV_API LilvNode*
lilv_new_bool(LilvWorld* world, bool val);

LILV_API void
lilv_node_free(LilvNode* val);

LILV_API LilvNode*
lilv_node_duplicate(const LilvNode* val);

LILV_API bool
lilv_node_equals(const LilvNode* value, const LilvNode* other);

LILV_API char*
lilv_node_get_turtle_token(const LilvNode* value);

LILV_API bool
lilv_node_is_uri(const LilvNode* value);

LILV_API const char*
lilv_node_as_uri(const LilvNode* value);

LILV_API bool
lilv_node_is_blank(const LilvNode* value);

LILV_API const char*
lilv_node_as_blank(const LilvNode* value);

LILV_API bool
lilv_node_is_literal(const LilvNode* value);

LILV_API bool
lilv_node_is_string(const LilvNode* value);

LILV_API const char*
lilv_node_as_string(const LilvNode* value);

LILV_API char*
lilv_node_get_path(const LilvNode* value, char** hostname);

LILV_API bool
lilv_node_is_float(const LilvNode* value);

LILV_API float
lilv_node_as_float(const LilvNode* value);

LILV_API bool
lilv_node_is_int(const LilvNode* value);

LILV_API int
lilv_node_as_int(const LilvNode* value);

LILV_API bool
lilv_node_is_bool(const LilvNode* value);

LILV_API bool
lilv_node_as_bool(const LilvNode* value);

 
/* Collections */

#define LILV_FOREACH(colltype, iter, collection) \
        for (LilvIter* iter = lilv_ ## colltype ## _begin(collection); \
             !lilv_ ## colltype ## _is_end(collection, iter); \
             iter = lilv_ ## colltype ## _next(collection, iter))
 
/* LilvPluginClasses */
 
LILV_API void
lilv_plugin_classes_free(LilvPluginClasses* collection);
 
LILV_API unsigned
lilv_plugin_classes_size(const LilvPluginClasses* collection);
 
LILV_API LilvIter*
lilv_plugin_classes_begin(const LilvPluginClasses* collection);
 
LILV_API const LilvPluginClass*
lilv_plugin_classes_get(const LilvPluginClasses* collection, LilvIter* i);
 
LILV_API LilvIter*
lilv_plugin_classes_next(const LilvPluginClasses* collection, LilvIter* i);
 
LILV_API bool
lilv_plugin_classes_is_end(const LilvPluginClasses* collection, LilvIter* i);

LILV_API const LilvPluginClass*
lilv_plugin_classes_get_by_uri(const LilvPluginClasses* classes,
                               const LilvNode*          uri);
 
/* ScalePoints */
 
LILV_API void
lilv_scale_points_free(LilvScalePoints* collection);
 
LILV_API unsigned
lilv_scale_points_size(const LilvScalePoints* collection);
 
LILV_API LilvIter*
lilv_scale_points_begin(const LilvScalePoints* collection);
 
LILV_API const LilvScalePoint*
lilv_scale_points_get(const LilvScalePoints* collection, LilvIter* i);
 
LILV_API LilvIter*
lilv_scale_points_next(const LilvScalePoints* collection, LilvIter* i);
 
LILV_API bool
lilv_scale_points_is_end(const LilvScalePoints* collection, LilvIter* i);
 
/* UIs */
 
LILV_API void
lilv_uis_free(LilvUIs* collection);
 
LILV_API unsigned
lilv_uis_size(const LilvUIs* collection);
 
LILV_API LilvIter*
lilv_uis_begin(const LilvUIs* collection);
 
LILV_API const LilvUI*
lilv_uis_get(const LilvUIs* collection, LilvIter* i);
 
LILV_API LilvIter*
lilv_uis_next(const LilvUIs* collection, LilvIter* i);
 
LILV_API bool
lilv_uis_is_end(const LilvUIs* collection, LilvIter* i);

LILV_API const LilvUI*
lilv_uis_get_by_uri(const LilvUIs*  uis,
                    const LilvNode* uri);
 
/* Nodes */
 
LILV_API void
lilv_nodes_free(LilvNodes* collection);
 
LILV_API unsigned
lilv_nodes_size(const LilvNodes* collection);
 
LILV_API LilvIter*
lilv_nodes_begin(const LilvNodes* collection);
 
LILV_API const LilvNode*
lilv_nodes_get(const LilvNodes* collection, LilvIter* i);
 
LILV_API LilvIter*
lilv_nodes_next(const LilvNodes* collection, LilvIter* i);
 
LILV_API bool
lilv_nodes_is_end(const LilvNodes* collection, LilvIter* i);
 
LILV_API LilvNode*
lilv_nodes_get_first(const LilvNodes* collection);

LILV_API bool
lilv_nodes_contains(const LilvNodes* values, const LilvNode* value);

LILV_API LilvNodes*
lilv_nodes_merge(const LilvNodes* a, const LilvNodes* b);
 
/* Plugins */
 
LILV_API unsigned
lilv_plugins_size(const LilvPlugins* collection);
 
LILV_API LilvIter*
lilv_plugins_begin(const LilvPlugins* collection);
 
LILV_API const LilvPlugin*
lilv_plugins_get(const LilvPlugins* collection, LilvIter* i);
 
LILV_API LilvIter*
lilv_plugins_next(const LilvPlugins* collection, LilvIter* i);
 
LILV_API bool
lilv_plugins_is_end(const LilvPlugins* collection, LilvIter* i);

LILV_API const LilvPlugin*
lilv_plugins_get_by_uri(const LilvPlugins* plugins,
                        const LilvNode*    uri);


LILV_API LilvWorld*
lilv_world_new(void);

#define LILV_OPTION_FILTER_LANG "http://drobilla.net/ns/lilv#filter-lang"

#define LILV_OPTION_DYN_MANIFEST "http://drobilla.net/ns/lilv#dyn-manifest"

LILV_API void
lilv_world_set_option(LilvWorld*      world,
                      const char*     uri,
                      const LilvNode* value);

LILV_API void
lilv_world_free(LilvWorld* world);

LILV_API void
lilv_world_load_all(LilvWorld* world, const char* lv2_path);

LILV_API void
lilv_world_load_bundle(LilvWorld*      world,
                       const LilvNode* bundle_uri);

LILV_API void
lilv_world_load_specifications(LilvWorld* world);

LILV_API void
lilv_world_load_plugin_classes(LilvWorld* world);

LILV_API int
lilv_world_unload_bundle(LilvWorld* world, const LilvNode* bundle_uri);

LILV_API int
lilv_world_load_resource(LilvWorld*      world,
                         const LilvNode* resource);

LILV_API int
lilv_world_unload_resource(LilvWorld*      world,
                           const LilvNode* resource);

LILV_API const LilvPluginClass*
lilv_world_get_plugin_class(const LilvWorld* world);

LILV_API const LilvPluginClasses*
lilv_world_get_plugin_classes(const LilvWorld* world);

LILV_API const LilvPlugins*
lilv_world_get_all_plugins(const LilvWorld* world);

LILV_API LilvNodes*
lilv_world_find_nodes(LilvWorld*      world,
                      const LilvNode* subject,
                      const LilvNode* predicate,
                      const LilvNode* object);

LILV_API LilvNode*
lilv_world_get(LilvWorld*      world,
               const LilvNode* subject,
               const LilvNode* predicate,
               const LilvNode* object);

LILV_API bool
lilv_world_ask(LilvWorld*      world,
               const LilvNode* subject,
               const LilvNode* predicate,
               const LilvNode* object);

LILV_API LilvNode*
lilv_world_get_symbol(LilvWorld* world, const LilvNode* subject);


LILV_API bool
lilv_plugin_verify(const LilvPlugin* plugin);

LILV_API const LilvNode*
lilv_plugin_get_uri(const LilvPlugin* plugin);

LILV_API const LilvNode*
lilv_plugin_get_bundle_uri(const LilvPlugin* plugin);

LILV_API const LilvNodes*
lilv_plugin_get_data_uris(const LilvPlugin* plugin);

LILV_API const LilvNode*
lilv_plugin_get_library_uri(const LilvPlugin* plugin);

LILV_API LilvNode*
lilv_plugin_get_name(const LilvPlugin* plugin);

LILV_API const LilvPluginClass*
lilv_plugin_get_class(const LilvPlugin* plugin);

LILV_API LilvNodes*
lilv_plugin_get_value(const LilvPlugin* p,
                      const LilvNode*   predicate);

LILV_API bool
lilv_plugin_has_feature(const LilvPlugin* p,
                        const LilvNode*   feature_uri);

LILV_API LilvNodes*
lilv_plugin_get_supported_features(const LilvPlugin* p);

LILV_API LilvNodes*
lilv_plugin_get_required_features(const LilvPlugin* p);

LILV_API LilvNodes*
lilv_plugin_get_optional_features(const LilvPlugin* p);

LILV_API bool
lilv_plugin_has_extension_data(const LilvPlugin* p,
                               const LilvNode*   uri);

LILV_API LilvNodes*
lilv_plugin_get_extension_data(const LilvPlugin* p);

LILV_API uint32_t
lilv_plugin_get_num_ports(const LilvPlugin* p);

LILV_API void
lilv_plugin_get_port_ranges_float(const LilvPlugin* p,
                                  float*            min_values,
                                  float*            max_values,
                                  float*            def_values);

LILV_API uint32_t
lilv_plugin_get_num_ports_of_class(const LilvPlugin* p,
                                   const LilvNode*   class_1, ...);
 
#ifndef SWIG
LILV_API uint32_t
lilv_plugin_get_num_ports_of_class_va(const LilvPlugin* p,
                                      const LilvNode*   class_1,
                                      va_list           args);
#endif

LILV_API bool
lilv_plugin_has_latency(const LilvPlugin* p);

LILV_API uint32_t
lilv_plugin_get_latency_port_index(const LilvPlugin* p);

LILV_API const LilvPort*
lilv_plugin_get_port_by_index(const LilvPlugin* plugin,
                              uint32_t          index);

LILV_API const LilvPort*
lilv_plugin_get_port_by_symbol(const LilvPlugin* plugin,
                               const LilvNode*   symbol);

LILV_API const LilvPort*
lilv_plugin_get_port_by_designation(const LilvPlugin* plugin,
                                    const LilvNode*   port_class,
                                    const LilvNode*   designation);

LILV_API LilvNode*
lilv_plugin_get_project(const LilvPlugin* plugin);

LILV_API LilvNode*
lilv_plugin_get_author_name(const LilvPlugin* plugin);

LILV_API LilvNode*
lilv_plugin_get_author_email(const LilvPlugin* plugin);

LILV_API LilvNode*
lilv_plugin_get_author_homepage(const LilvPlugin* plugin);

LILV_API bool
lilv_plugin_is_replaced(const LilvPlugin* plugin);

LILV_API void
lilv_plugin_write_description(LilvWorld*        world,
                              const LilvPlugin* plugin,
                              const LilvNode*   base_uri,
                              FILE*             plugin_file);

LILV_API void
lilv_plugin_write_manifest_entry(LilvWorld*        world,
                                 const LilvPlugin* plugin,
                                 const LilvNode*   base_uri,
                                 FILE*             manifest_file,
                                 const char*       plugin_file_path);

LILV_API LilvNodes*
lilv_plugin_get_related(const LilvPlugin* plugin, const LilvNode* type);


LILV_API const LilvNode*
lilv_port_get_node(const LilvPlugin* plugin,
                   const LilvPort*   port);

LILV_API LilvNodes*
lilv_port_get_value(const LilvPlugin* plugin,
                    const LilvPort*   port,
                    const LilvNode*   predicate);

LILV_API LilvNode*
lilv_port_get(const LilvPlugin* plugin,
              const LilvPort*   port,
              const LilvNode*   predicate);

LILV_API LilvNodes*
lilv_port_get_properties(const LilvPlugin* plugin,
                         const LilvPort*   port);

LILV_API bool
lilv_port_has_property(const LilvPlugin* p,
                       const LilvPort*   port,
                       const LilvNode*   property_uri);

LILV_API bool
lilv_port_supports_event(const LilvPlugin* p,
                         const LilvPort*   port,
                         const LilvNode*   event_type);

LILV_API uint32_t
lilv_port_get_index(const LilvPlugin* plugin,
                    const LilvPort*   port);

LILV_API const LilvNode*
lilv_port_get_symbol(const LilvPlugin* plugin,
                     const LilvPort*   port);

LILV_API LilvNode*
lilv_port_get_name(const LilvPlugin* plugin,
                   const LilvPort*   port);

LILV_API const LilvNodes*
lilv_port_get_classes(const LilvPlugin* plugin,
                      const LilvPort*   port);

LILV_API bool
lilv_port_is_a(const LilvPlugin* plugin,
               const LilvPort*   port,
               const LilvNode*   port_class);

LILV_API void
lilv_port_get_range(const LilvPlugin* plugin,
                    const LilvPort*   port,
                    LilvNode**        deflt,
                    LilvNode**        min,
                    LilvNode**        max);

LILV_API LilvScalePoints*
lilv_port_get_scale_points(const LilvPlugin* plugin,
                           const LilvPort*   port);


LILV_API LilvState*
lilv_state_new_from_world(LilvWorld*          world,
                          const LV2_URID_Map* map,
                          const LilvNode*     subject);

LILV_API LilvState*
lilv_state_new_from_file(LilvWorld*          world,
                         const LV2_URID_Map* map,
                         const LilvNode*     subject,
                         const char*         path);

LILV_API LilvState*
lilv_state_new_from_string(LilvWorld*          world,
                           const LV2_URID_Map* map,
                           const char*         str);

typedef const void* (*LilvGetPortValueFunc)(const char* port_symbol,
                                            void*       user_data,
                                            uint32_t*   size,
                                            uint32_t*   type);

LILV_API LilvState*
lilv_state_new_from_instance(const LilvPlugin*          plugin,
                             LilvInstance*              instance,
                             LV2_URID_Map*              map,
                             const char*                file_dir,
                             const char*                copy_dir,
                             const char*                link_dir,
                             const char*                save_dir,
                             LilvGetPortValueFunc       get_value,
                             void*                      user_data,
                             uint32_t                   flags,
                             const LV2_Feature *const * features);

LILV_API void
lilv_state_free(LilvState* state);

LILV_API bool
lilv_state_equals(const LilvState* a, const LilvState* b);

LILV_API unsigned
lilv_state_get_num_properties(const LilvState* state);

LILV_API const LilvNode*
lilv_state_get_plugin_uri(const LilvState* state);

LILV_API const LilvNode*
lilv_state_get_uri(const LilvState* state);

LILV_API const char*
lilv_state_get_label(const LilvState* state);

LILV_API void
lilv_state_set_label(LilvState*  state,
                     const char* label);

LILV_API int
lilv_state_set_metadata(LilvState*  state,
                        uint32_t    key,
                        const void* value,
                        size_t      size,
                        uint32_t    type,
                        uint32_t    flags);

typedef void (*LilvSetPortValueFunc)(const char* port_symbol,
                                     void*       user_data,
                                     const void* value,
                                     uint32_t    size,
                                     uint32_t    type);

LILV_API void
lilv_state_emit_port_values(const LilvState*     state,
                            LilvSetPortValueFunc set_value,
                            void*                user_data);

LILV_API void
lilv_state_restore(const LilvState*           state,
                   const LV2_State_Interface* iface,
                   LV2_Handle                 handle,
                   LilvSetPortValueFunc       set_value,
                   void*                      user_data,
                   uint32_t                   flags,
                   const LV2_Feature *const * features);

LILV_API int
lilv_state_save(LilvWorld*                 world,
                LV2_URID_Map*              map,
                LV2_URID_Unmap*            unmap,
                const LilvState*           state,
                const char*                uri,
                const char*                dir,
                const char*                filename);

LILV_API char*
lilv_state_to_string(LilvWorld*       world,
                     LV2_URID_Map*    map,
                     LV2_URID_Unmap*  unmap,
                     const LilvState* state,
                     const char*      uri,
                     const char*      base_uri);

LILV_API int
lilv_state_delete(LilvWorld*       world,
                  const LilvState* state);


LILV_API const LilvNode*
lilv_scale_point_get_label(const LilvScalePoint* point);

LILV_API const LilvNode*
lilv_scale_point_get_value(const LilvScalePoint* point);


LILV_API const LilvNode*
lilv_plugin_class_get_parent_uri(const LilvPluginClass* plugin_class);

LILV_API const LilvNode*
lilv_plugin_class_get_uri(const LilvPluginClass* plugin_class);

LILV_API const LilvNode*
lilv_plugin_class_get_label(const LilvPluginClass* plugin_class);

LILV_API LilvPluginClasses*
lilv_plugin_class_get_children(const LilvPluginClass* plugin_class);


 
/* Instance of a plugin.
   This is exposed in the ABI to allow inlining of performance critical
   functions like lilv_instance_run() (simple wrappers of functions in lv2.h).
   This is for performance reasons, user code should not use this definition
   in any way (which is why it is not machine documented).
   Truly private implementation details are hidden via `pimpl`.
*/
struct LilvInstanceImpl {
        const LV2_Descriptor* lv2_descriptor;
        LV2_Handle            lv2_handle;
        void*                 pimpl;
};


LILV_API LilvInstance*
lilv_plugin_instantiate(const LilvPlugin*        plugin,
                        double                   sample_rate,
                        const LV2_Feature*const* features);

LILV_API void
lilv_instance_free(LilvInstance* instance);
 
#ifndef LILV_INTERNAL

static inline const char*
lilv_instance_get_uri(const LilvInstance* instance)
{
        return instance->lv2_descriptor->URI;
}

static inline void
lilv_instance_connect_port(LilvInstance* instance,
                           uint32_t      port_index,
                           void*         data_location)
{
        instance->lv2_descriptor->connect_port
                (instance->lv2_handle, port_index, data_location);
}

static inline void
lilv_instance_activate(LilvInstance* instance)
{
        if (instance->lv2_descriptor->activate)
                instance->lv2_descriptor->activate(instance->lv2_handle);
}

static inline void
lilv_instance_run(LilvInstance* instance,
                  uint32_t      sample_count)
{
        instance->lv2_descriptor->run(instance->lv2_handle, sample_count);
}

static inline void
lilv_instance_deactivate(LilvInstance* instance)
{
        if (instance->lv2_descriptor->deactivate)
                instance->lv2_descriptor->deactivate(instance->lv2_handle);
}

static inline const void*
lilv_instance_get_extension_data(const LilvInstance* instance,
                                 const char*         uri)
{
        if (instance->lv2_descriptor->extension_data)
                return instance->lv2_descriptor->extension_data(uri);
        else
                return NULL;
}

static inline const LV2_Descriptor*
lilv_instance_get_descriptor(const LilvInstance* instance)
{
        return instance->lv2_descriptor;
}

static inline LV2_Handle
lilv_instance_get_handle(const LilvInstance* instance)
{
        return instance->lv2_handle;
}
 
#endif /* LILV_INTERNAL */


LILV_API LilvUIs*
lilv_plugin_get_uis(const LilvPlugin* plugin);

LILV_API const LilvNode*
lilv_ui_get_uri(const LilvUI* ui);

LILV_API const LilvNodes*
lilv_ui_get_classes(const LilvUI* ui);

LILV_API bool
lilv_ui_is_a(const LilvUI* ui, const LilvNode* class_uri);

typedef unsigned (*LilvUISupportedFunc)(const char* container_type_uri,
                                        const char* ui_type_uri);

LILV_API unsigned
lilv_ui_is_supported(const LilvUI*       ui,
                     LilvUISupportedFunc supported_func,
                     const LilvNode*     container_type,
                     const LilvNode**    ui_type);

LILV_API const LilvNode*
lilv_ui_get_bundle_uri(const LilvUI* ui);

LILV_API const LilvNode*
lilv_ui_get_binary_uri(const LilvUI* ui);

LILV_API LilvNode*
lilv_plugin_get_modgui_resources_directory(const LilvPlugin* plugin);
 
LILV_API LilvNode*
lilv_plugin_get_modgui_stylesheet(const LilvPlugin* plugin);
 
LILV_API LilvNode*
lilv_plugin_get_modgui_icon_template(const LilvPlugin* plugin);
 
LILV_API LilvNode*
lilv_plugin_get_modgui_settings_template(const LilvPlugin* plugin);
 
LILV_API LilvNode*
lilv_plugin_get_modgui_template_data(const LilvPlugin* plugin);
 
LILV_API LilvNode*
lilv_plugin_get_modgui_screenshot(const LilvPlugin* plugin);
 
LILV_API LilvNode*
lilv_plugin_get_modgui_thumbnail(const LilvPlugin* plugin);
 
LILV_API const LilvNodes*
lilv_ui_get_supported_features(const LilvUI* ui);
 
LILV_API const LilvNodes*
lilv_ui_get_required_features(const LilvUI* ui);
 
LILV_API const LilvNodes*
lilv_ui_get_optional_features(const LilvUI* ui);
 
LILV_API const LilvNodes*
lilv_ui_get_extension_data(const LilvUI* ui);

 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* LILV_LILV_H */