GNOME.org
 

[beast: 6/49] BSE: move Bse::ErrorType to bseapi.idl, but keep BseErrorType for GType compatibility

commit 5e5fb0129085067c4cf9d521a048f309487db847
Author: Tim Janik <timj gnu org>
Date:   Sun Jun 21 01:58:03 2015 +0200

    BSE: move Bse::ErrorType to bseapi.idl, but keep BseErrorType for GType compatibility

 bse/bseapi.idl  |   79 +++++++++++++++++++++++++++++++
 bse/bseenums.cc |   89 +----------------------------------
 bse/bseenums.hh |  139 ++++++++++++++++++++++++++++---------------------------
 bse/bseutils.hh |    1 -
 4 files changed, 151 insertions(+), 157 deletions(-)
---
diff --git a/bse/bseapi.idl b/bse/bseapi.idl
index 1a29ed6..e20831e 100644
--- a/bse/bseapi.idl
+++ b/bse/bseapi.idl
@@ -6,6 +6,85 @@
 
 namespace Bse {
 
+enum ErrorType {
+  ERROR_NONE = Enum (0, "OK"),
+  ERROR_INTERNAL = Enum (1, "Internal error (please report)"),
+  ERROR_UNKNOWN = Enum (2, "Unknown error"),
+  ERROR_IO = Enum (3, "Input/output error"),
+  ERROR_PERMS = Enum (4, "Insufficient permissions"),
+  // file errors
+  ERROR_FILE_BUSY = Enum (5, "Device or resource busy"),
+  ERROR_FILE_EXISTS = Enum (6, "File exists already"),
+  ERROR_FILE_EOF = Enum (7, "End of file"),
+  ERROR_FILE_EMPTY = Enum (8, "File empty"),
+  ERROR_FILE_NOT_FOUND = Enum (9, "No such file, device or directory"),
+  ERROR_FILE_IS_DIR = Enum (10, "Is a directory"),
+  ERROR_FILE_OPEN_FAILED = Enum (11, "Open failed"),
+  ERROR_FILE_SEEK_FAILED = Enum (12, "Seek failed"),
+  ERROR_FILE_READ_FAILED = Enum (13, "Read failed"),
+  ERROR_FILE_WRITE_FAILED = Enum (14, "Write failed"),
+  // out of resource conditions
+  ERROR_MANY_FILES = Enum (15, "Too many open files"),
+  ERROR_NO_FILES = Enum (16, "Too many open files in system"),
+  ERROR_NO_SPACE = Enum (17, "No space left on device"),
+  ERROR_NO_MEMORY = Enum (18, "Out of memory"),
+  // content errors
+  ERROR_NO_HEADER = Enum (19, "Failed to detect header"),
+  ERROR_NO_SEEK_INFO = Enum (20, "Failed to retrieve seek information"),
+  ERROR_NO_DATA = Enum (21, "No data available"),
+  ERROR_DATA_CORRUPT = Enum (22, "Data corrupt"),
+  ERROR_WRONG_N_CHANNELS = Enum (23, "Wrong number of channels"),
+  ERROR_FORMAT_INVALID = Enum (24, "Invalid format"),
+  ERROR_FORMAT_UNKNOWN = Enum (25, "Unknown format"),
+  ERROR_DATA_UNMATCHED = Enum (26, "Requested data values unmatched"),
+  // miscellaneous errors
+  ERROR_TEMP = Enum (27, "Temporary error"),
+  ERROR_WAVE_NOT_FOUND = Enum (28, "No such wave"),
+  ERROR_CODEC_FAILURE = Enum (29, "Codec failure"),
+  ERROR_UNIMPLEMENTED = Enum (30, "Functionality not implemented"),
+  ERROR_INVALID_PROPERTY = Enum (31, "Invalid object property"),
+  ERROR_INVALID_MIDI_CONTROL = Enum (32, "Invalid MIDI control type"),
+  ERROR_PARSE_ERROR = Enum (33, "Parsing error"),
+  ERROR_SPAWN = Enum (34, "Failed to spawn child process"),
+  // Device errors
+  ERROR_DEVICE_NOT_AVAILABLE = Enum (35, "No device (driver) available"),
+  ERROR_DEVICE_ASYNC = Enum (36, "Device not async capable"),
+  ERROR_DEVICE_BUSY = Enum (37, "Device busy"),
+  ERROR_DEVICE_FORMAT = Enum (38, "Failed to configure device format"),
+  ERROR_DEVICE_BUFFER = Enum (39, "Failed to configure device buffer"),
+  ERROR_DEVICE_LATENCY = Enum (40, "Failed to configure device latency"),
+  ERROR_DEVICE_CHANNELS = Enum (41, "Failed to configure number of device channels"),
+  ERROR_DEVICE_FREQUENCY = Enum (42, "Failed to configure device frequency"),
+  ERROR_DEVICES_MISMATCH = Enum (43, "Device configurations mismatch"),
+  // BseSource errors
+  ERROR_SOURCE_NO_SUCH_MODULE = Enum (44, "No such synthesis module"),
+  ERROR_SOURCE_NO_SUCH_ICHANNEL = Enum (45, "No such input channel"),
+  ERROR_SOURCE_NO_SUCH_OCHANNEL = Enum (46, "No such output channel"),
+  ERROR_SOURCE_NO_SUCH_CONNECTION = Enum (47, "Input/Output channels not connected"),
+  ERROR_SOURCE_PRIVATE_ICHANNEL = Enum (48, "Input channel is private"),
+  ERROR_SOURCE_ICHANNEL_IN_USE = Enum (49, "Input channel already in use"),
+  ERROR_SOURCE_CHANNELS_CONNECTED = Enum (50, "Input/output channels already connected"),
+  ERROR_SOURCE_CONNECTION_INVALID = Enum (51, "Invalid synthesis module connection"),
+  ERROR_SOURCE_PARENT_MISMATCH = Enum (52, "Parent mismatch"),
+  ERROR_SOURCE_BAD_LOOPBACK = Enum (53, "Bad loopback"),
+  ERROR_SOURCE_BUSY = Enum (54, "Synthesis module currently busy"),
+  ERROR_SOURCE_TYPE_INVALID = Enum (55, "Invalid synthsis module type"),
+  // BseProcedure errors
+  ERROR_PROC_NOT_FOUND = Enum (56, "No such procedure"),
+  ERROR_PROC_BUSY = Enum (57, "Procedure currently busy"),
+  ERROR_PROC_PARAM_INVAL = Enum (58, "Procedure parameter invalid"),
+  ERROR_PROC_EXECUTION = Enum (59, "Procedure execution failed"),
+  ERROR_PROC_ABORT = Enum (60, "Procedure execution aborted"),
+  // various procedure errors
+  ERROR_NO_ENTRY = Enum (61, "No such entry"),
+  ERROR_NO_EVENT = Enum (62, "No such event"),
+  ERROR_NO_TARGET = Enum (63, "No target"),
+  ERROR_NOT_OWNER = Enum (64, "Ownership mismatch"),
+  ERROR_INVALID_OFFSET = Enum (65, "Invalid offset"),
+  ERROR_INVALID_DURATION = Enum (66, "Invalid duration"),
+  ERROR_INVALID_OVERLAP = Enum (67, "Invalid overlap"),
+};
+
 /// Basic object type for all BSE objects.
 interface Object {
   String debug_name (); ///< Object name useful for debugging output.
diff --git a/bse/bseenums.cc b/bse/bseenums.cc
index dca2329..6a6fb01 100644
--- a/bse/bseenums.cc
+++ b/bse/bseenums.cc
@@ -67,93 +67,8 @@ bse_error_nick (BseErrorType error_value)
 const char*
 bse_error_blurb (BseErrorType error_value)
 {
-  GEnumValue *ev;
-
-  if (!bse_error_class)
-    bse_error_class = (GEnumClass*) g_type_class_ref (BSE_TYPE_ERROR_TYPE);
-
-  switch (error_value)
-    {
-    case BSE_ERROR_NONE:                        return _("Everything went well");
-    case BSE_ERROR_INTERNAL:                    return _("Internal error (please report)");
-    case BSE_ERROR_UNKNOWN:                     return _("Unknown error");
-    case BSE_ERROR_IO:                          return _("Input/output error");
-    case BSE_ERROR_PERMS:                       return _("Insufficient permission");
-      /* file errors */
-    case BSE_ERROR_FILE_BUSY:                   return _("Device or resource busy");
-    case BSE_ERROR_FILE_EXISTS:                 return _("File exists already");
-    case BSE_ERROR_FILE_EOF:                    return _("Premature EOF");
-    case BSE_ERROR_FILE_EMPTY:                  return _("File empty");
-    case BSE_ERROR_FILE_NOT_FOUND:              return _("No such file, device or directory");
-    case BSE_ERROR_FILE_IS_DIR:                 return _("Is a directory");
-    case BSE_ERROR_FILE_OPEN_FAILED:            return _("Open failed");
-    case BSE_ERROR_FILE_SEEK_FAILED:            return _("Seek failed");
-    case BSE_ERROR_FILE_READ_FAILED:            return _("Read failed");
-    case BSE_ERROR_FILE_WRITE_FAILED:           return _("Write failed");
-      /* out of resource conditions */
-    case BSE_ERROR_MANY_FILES:                  return _("Too many open files");
-    case BSE_ERROR_NO_FILES:                    return _("Too many open files in system");
-    case BSE_ERROR_NO_SPACE:                    return _("No space left on device");
-    case BSE_ERROR_NO_MEMORY:                   return _("Out of memory");
-      /* content errors */
-    case BSE_ERROR_NO_HEADER:                   return _("Failed to detect (start of) header");
-    case BSE_ERROR_NO_SEEK_INFO:                return _("Failed to retrieve seek information");
-    case BSE_ERROR_NO_DATA:                     return _("No data available");
-    case BSE_ERROR_DATA_CORRUPT:                return _("Data corrupt");
-    case BSE_ERROR_WRONG_N_CHANNELS:            return _("Wrong number of channels");
-    case BSE_ERROR_FORMAT_INVALID:              return _("Invalid format");
-    case BSE_ERROR_FORMAT_UNKNOWN:              return _("Unknown format");
-    case BSE_ERROR_DATA_UNMATCHED:              return _("Requested data values unmatched");
-      /* miscellaneous errors */
-    case BSE_ERROR_TEMP:                        return _("Temporary error");
-    case BSE_ERROR_WAVE_NOT_FOUND:              return _("No such wave");
-    case BSE_ERROR_CODEC_FAILURE:               return _("CODEC failure");
-    case BSE_ERROR_UNIMPLEMENTED:              return _("Functionality not implemented");
-    case BSE_ERROR_INVALID_PROPERTY:           return _("Invalid object property");
-    case BSE_ERROR_INVALID_MIDI_CONTROL:       return _("Invalid MIDI control type");
-    case BSE_ERROR_PARSE_ERROR:                        return _("Parsing error");
-    case BSE_ERROR_SPAWN:                      return _("Failed to spawn child process");
-      /* Device errors */
-    case BSE_ERROR_DEVICE_NOT_AVAILABLE:       return _("No device (driver) available");
-    case BSE_ERROR_DEVICE_ASYNC:               return _("Device not async capable");
-    case BSE_ERROR_DEVICE_BUSY:                        return _("Device busy");
-    case BSE_ERROR_DEVICE_FORMAT:               return _("Failed to configure device format");
-    case BSE_ERROR_DEVICE_BUFFER:               return _("Failed to configure device buffer");
-    case BSE_ERROR_DEVICE_LATENCY:              return _("Failed to configure device latency");
-    case BSE_ERROR_DEVICE_CHANNELS:             return _("Failed to configure number of device channels");
-    case BSE_ERROR_DEVICE_FREQUENCY:            return _("Failed to configure device frequency");
-    case BSE_ERROR_DEVICES_MISMATCH:            return _("Device configurations mismatch");
-      /* BseSource errors */
-    case BSE_ERROR_SOURCE_NO_SUCH_MODULE:      return _("No such synthesis module");
-    case BSE_ERROR_SOURCE_NO_SUCH_ICHANNEL:    return _("No such input channel");
-    case BSE_ERROR_SOURCE_NO_SUCH_OCHANNEL:    return _("No such output channel");
-    case BSE_ERROR_SOURCE_NO_SUCH_CONNECTION:  return _("Input/Output channels not connected");
-    case BSE_ERROR_SOURCE_PRIVATE_ICHANNEL:    return _("Input channel is private");
-    case BSE_ERROR_SOURCE_ICHANNEL_IN_USE:     return _("Input channel already in use");
-    case BSE_ERROR_SOURCE_CHANNELS_CONNECTED:  return _("Input/Output channels already connected");
-    case BSE_ERROR_SOURCE_CONNECTION_INVALID:  return _("Invalid synthesis module connection");
-    case BSE_ERROR_SOURCE_PARENT_MISMATCH:     return _("Parent mismatch");
-    case BSE_ERROR_SOURCE_BAD_LOOPBACK:                return _("Bad loopback");
-    case BSE_ERROR_SOURCE_BUSY:                        return _("Synthesis module currently busy");
-    case BSE_ERROR_SOURCE_TYPE_INVALID:                return _("Invalid synthsis module type");
-      /* BseProcedure errors */
-    case BSE_ERROR_PROC_NOT_FOUND:             return _("No such procedure");
-    case BSE_ERROR_PROC_BUSY:                  return _("Procedure currently busy"); /* recursion */
-    case BSE_ERROR_PROC_PARAM_INVAL:           return _("Procedure parameter invalid");
-    case BSE_ERROR_PROC_EXECUTION:             return _("Procedure execution failed");
-    case BSE_ERROR_PROC_ABORT:                 return _("Procedure execution aborted");
-      /* various procedure errors */
-    case BSE_ERROR_NO_ENTRY:                   return _("No such entry");
-    case BSE_ERROR_NO_EVENT:                   return _("No such event");
-    case BSE_ERROR_NO_TARGET:                  return _("No target");
-    case BSE_ERROR_NOT_OWNER:                  return _("Ownership mismatch");
-    case BSE_ERROR_INVALID_OFFSET:             return _("Invalid offset");
-    case BSE_ERROR_INVALID_DURATION:           return _("Invalid duration");
-    case BSE_ERROR_INVALID_OVERLAP:            return _("Invalid overlap");
-    }
-
-  ev = g_enum_get_value (bse_error_class, error_value);
-  return ev ? ev->value_nick : NULL;
+  const Rapicorn::Aida::EnumValue *ev = Rapicorn::Aida::enum_info<Bse::ErrorType>().find_value (error_value);
+  return ev ? ev->blurb : NULL;
 }
 
 BseErrorType
diff --git a/bse/bseenums.hh b/bse/bseenums.hh
index 8b2fc1f..bf690ae 100644
--- a/bse/bseenums.hh
+++ b/bse/bseenums.hh
@@ -2,8 +2,9 @@
 #ifndef __BSE_ENUMS_H__
 #define __BSE_ENUMS_H__
 
-#include <bse/bsetype.hh>
 #include <bse/gsldefs.hh>
+#include <bse/bsetype.hh>
+#include <bse/bseserverapi.hh>
 
 
 G_BEGIN_DECLS
@@ -50,83 +51,83 @@ typedef enum
 } BseMagicFlags;
 typedef enum
 {
-  BSE_ERROR_NONE               = 0,
-  BSE_ERROR_INTERNAL,
-  BSE_ERROR_UNKNOWN,
+  BSE_ERROR_NONE                               = Bse::ERROR_NONE,
+  BSE_ERROR_INTERNAL                            = Bse::ERROR_INTERNAL,
+  BSE_ERROR_UNKNOWN                            = Bse::ERROR_UNKNOWN,
   /* general errors */
-  BSE_ERROR_IO,
-  BSE_ERROR_PERMS,
+  BSE_ERROR_IO                                 = Bse::ERROR_IO,
+  BSE_ERROR_PERMS                              = Bse::ERROR_PERMS,
   /* file errors */
-  BSE_ERROR_FILE_BUSY,
-  BSE_ERROR_FILE_EXISTS,
-  BSE_ERROR_FILE_EOF,
-  BSE_ERROR_FILE_EMPTY,
-  BSE_ERROR_FILE_NOT_FOUND,
-  BSE_ERROR_FILE_IS_DIR,
-  BSE_ERROR_FILE_OPEN_FAILED,
-  BSE_ERROR_FILE_SEEK_FAILED,
-  BSE_ERROR_FILE_READ_FAILED,
-  BSE_ERROR_FILE_WRITE_FAILED,
+  BSE_ERROR_FILE_BUSY                          = Bse::ERROR_FILE_BUSY,
+  BSE_ERROR_FILE_EXISTS                                = Bse::ERROR_FILE_EXISTS,
+  BSE_ERROR_FILE_EOF                           = Bse::ERROR_FILE_EOF,
+  BSE_ERROR_FILE_EMPTY                         = Bse::ERROR_FILE_EMPTY,
+  BSE_ERROR_FILE_NOT_FOUND                     = Bse::ERROR_FILE_NOT_FOUND,
+  BSE_ERROR_FILE_IS_DIR                                = Bse::ERROR_FILE_IS_DIR,
+  BSE_ERROR_FILE_OPEN_FAILED                   = Bse::ERROR_FILE_OPEN_FAILED,
+  BSE_ERROR_FILE_SEEK_FAILED                   = Bse::ERROR_FILE_SEEK_FAILED,
+  BSE_ERROR_FILE_READ_FAILED                   = Bse::ERROR_FILE_READ_FAILED,
+  BSE_ERROR_FILE_WRITE_FAILED                  = Bse::ERROR_FILE_WRITE_FAILED,
   /* out of resource conditions */
-  BSE_ERROR_MANY_FILES,
-  BSE_ERROR_NO_FILES,
-  BSE_ERROR_NO_SPACE,
-  BSE_ERROR_NO_MEMORY,
+  BSE_ERROR_MANY_FILES                         = Bse::ERROR_MANY_FILES,
+  BSE_ERROR_NO_FILES                           = Bse::ERROR_NO_FILES,
+  BSE_ERROR_NO_SPACE                           = Bse::ERROR_NO_SPACE,
+  BSE_ERROR_NO_MEMORY                          = Bse::ERROR_NO_MEMORY,
   /* content errors */
-  BSE_ERROR_NO_HEADER,
-  BSE_ERROR_NO_SEEK_INFO,
-  BSE_ERROR_NO_DATA,
-  BSE_ERROR_DATA_CORRUPT,
-  BSE_ERROR_WRONG_N_CHANNELS,
-  BSE_ERROR_FORMAT_INVALID,
-  BSE_ERROR_FORMAT_UNKNOWN,
-  BSE_ERROR_DATA_UNMATCHED,
+  BSE_ERROR_NO_HEADER                          = Bse::ERROR_NO_HEADER,
+  BSE_ERROR_NO_SEEK_INFO                       = Bse::ERROR_NO_SEEK_INFO,
+  BSE_ERROR_NO_DATA                            = Bse::ERROR_NO_DATA,
+  BSE_ERROR_DATA_CORRUPT                       = Bse::ERROR_DATA_CORRUPT,
+  BSE_ERROR_WRONG_N_CHANNELS                   = Bse::ERROR_WRONG_N_CHANNELS,
+  BSE_ERROR_FORMAT_INVALID                     = Bse::ERROR_FORMAT_INVALID,
+  BSE_ERROR_FORMAT_UNKNOWN                     = Bse::ERROR_FORMAT_UNKNOWN,
+  BSE_ERROR_DATA_UNMATCHED                     = Bse::ERROR_DATA_UNMATCHED,
   /* miscellaneous errors */
-  BSE_ERROR_TEMP,
-  BSE_ERROR_WAVE_NOT_FOUND,
-  BSE_ERROR_CODEC_FAILURE,
-  BSE_ERROR_UNIMPLEMENTED,
-  BSE_ERROR_INVALID_PROPERTY,
-  BSE_ERROR_INVALID_MIDI_CONTROL,
-  BSE_ERROR_PARSE_ERROR,
-  BSE_ERROR_SPAWN,
+  BSE_ERROR_TEMP                               = Bse::ERROR_TEMP,
+  BSE_ERROR_WAVE_NOT_FOUND                     = Bse::ERROR_WAVE_NOT_FOUND,
+  BSE_ERROR_CODEC_FAILURE                      = Bse::ERROR_CODEC_FAILURE,
+  BSE_ERROR_UNIMPLEMENTED                      = Bse::ERROR_UNIMPLEMENTED,
+  BSE_ERROR_INVALID_PROPERTY                   = Bse::ERROR_INVALID_PROPERTY,
+  BSE_ERROR_INVALID_MIDI_CONTROL               = Bse::ERROR_INVALID_MIDI_CONTROL,
+  BSE_ERROR_PARSE_ERROR                                = Bse::ERROR_PARSE_ERROR,
+  BSE_ERROR_SPAWN                              = Bse::ERROR_SPAWN,
   /* Device errors */
-  BSE_ERROR_DEVICE_NOT_AVAILABLE,
-  BSE_ERROR_DEVICE_ASYNC,
-  BSE_ERROR_DEVICE_BUSY,
-  BSE_ERROR_DEVICE_FORMAT,
-  BSE_ERROR_DEVICE_BUFFER,
-  BSE_ERROR_DEVICE_LATENCY,
-  BSE_ERROR_DEVICE_CHANNELS,
-  BSE_ERROR_DEVICE_FREQUENCY,
-  BSE_ERROR_DEVICES_MISMATCH,
+  BSE_ERROR_DEVICE_NOT_AVAILABLE               = Bse::ERROR_DEVICE_NOT_AVAILABLE,
+  BSE_ERROR_DEVICE_ASYNC                       = Bse::ERROR_DEVICE_ASYNC,
+  BSE_ERROR_DEVICE_BUSY                        = Bse::ERROR_DEVICE_BUSY,
+  BSE_ERROR_DEVICE_FORMAT                      = Bse::ERROR_DEVICE_FORMAT,
+  BSE_ERROR_DEVICE_BUFFER                      = Bse::ERROR_DEVICE_BUFFER,
+  BSE_ERROR_DEVICE_LATENCY                     = Bse::ERROR_DEVICE_LATENCY,
+  BSE_ERROR_DEVICE_CHANNELS                    = Bse::ERROR_DEVICE_CHANNELS,
+  BSE_ERROR_DEVICE_FREQUENCY                   = Bse::ERROR_DEVICE_FREQUENCY,
+  BSE_ERROR_DEVICES_MISMATCH                   = Bse::ERROR_DEVICES_MISMATCH,
   /* BseSource errors */
-  BSE_ERROR_SOURCE_NO_SUCH_MODULE,
-  BSE_ERROR_SOURCE_NO_SUCH_ICHANNEL,
-  BSE_ERROR_SOURCE_NO_SUCH_OCHANNEL,
-  BSE_ERROR_SOURCE_NO_SUCH_CONNECTION,
-  BSE_ERROR_SOURCE_PRIVATE_ICHANNEL,
-  BSE_ERROR_SOURCE_ICHANNEL_IN_USE,
-  BSE_ERROR_SOURCE_CHANNELS_CONNECTED,
-  BSE_ERROR_SOURCE_CONNECTION_INVALID,
-  BSE_ERROR_SOURCE_PARENT_MISMATCH,
-  BSE_ERROR_SOURCE_BAD_LOOPBACK,
-  BSE_ERROR_SOURCE_BUSY,
-  BSE_ERROR_SOURCE_TYPE_INVALID,
+  BSE_ERROR_SOURCE_NO_SUCH_MODULE              = Bse::ERROR_SOURCE_NO_SUCH_MODULE,
+  BSE_ERROR_SOURCE_NO_SUCH_ICHANNEL            = Bse::ERROR_SOURCE_NO_SUCH_ICHANNEL,
+  BSE_ERROR_SOURCE_NO_SUCH_OCHANNEL            = Bse::ERROR_SOURCE_NO_SUCH_OCHANNEL,
+  BSE_ERROR_SOURCE_NO_SUCH_CONNECTION          = Bse::ERROR_SOURCE_NO_SUCH_CONNECTION,
+  BSE_ERROR_SOURCE_PRIVATE_ICHANNEL            = Bse::ERROR_SOURCE_PRIVATE_ICHANNEL,
+  BSE_ERROR_SOURCE_ICHANNEL_IN_USE             = Bse::ERROR_SOURCE_ICHANNEL_IN_USE,
+  BSE_ERROR_SOURCE_CHANNELS_CONNECTED          = Bse::ERROR_SOURCE_CHANNELS_CONNECTED,
+  BSE_ERROR_SOURCE_CONNECTION_INVALID          = Bse::ERROR_SOURCE_CONNECTION_INVALID,
+  BSE_ERROR_SOURCE_PARENT_MISMATCH             = Bse::ERROR_SOURCE_PARENT_MISMATCH,
+  BSE_ERROR_SOURCE_BAD_LOOPBACK                        = Bse::ERROR_SOURCE_BAD_LOOPBACK,
+  BSE_ERROR_SOURCE_BUSY                                = Bse::ERROR_SOURCE_BUSY,
+  BSE_ERROR_SOURCE_TYPE_INVALID                        = Bse::ERROR_SOURCE_TYPE_INVALID,
   /* BseProcedure errors */
-  BSE_ERROR_PROC_NOT_FOUND,
-  BSE_ERROR_PROC_BUSY,
-  BSE_ERROR_PROC_PARAM_INVAL,
-  BSE_ERROR_PROC_EXECUTION,
-  BSE_ERROR_PROC_ABORT,
+  BSE_ERROR_PROC_NOT_FOUND                     = Bse::ERROR_PROC_NOT_FOUND,
+  BSE_ERROR_PROC_BUSY                          = Bse::ERROR_PROC_BUSY,
+  BSE_ERROR_PROC_PARAM_INVAL                   = Bse::ERROR_PROC_PARAM_INVAL,
+  BSE_ERROR_PROC_EXECUTION                     = Bse::ERROR_PROC_EXECUTION,
+  BSE_ERROR_PROC_ABORT                         = Bse::ERROR_PROC_ABORT,
   /* various procedure errors */
-  BSE_ERROR_NO_ENTRY,
-  BSE_ERROR_NO_EVENT,
-  BSE_ERROR_NO_TARGET,
-  BSE_ERROR_NOT_OWNER,
-  BSE_ERROR_INVALID_OFFSET,
-  BSE_ERROR_INVALID_DURATION,
-  BSE_ERROR_INVALID_OVERLAP,
+  BSE_ERROR_NO_ENTRY                           = Bse::ERROR_NO_ENTRY,
+  BSE_ERROR_NO_EVENT                           = Bse::ERROR_NO_EVENT,
+  BSE_ERROR_NO_TARGET                          = Bse::ERROR_NO_TARGET,
+  BSE_ERROR_NOT_OWNER                          = Bse::ERROR_NOT_OWNER,
+  BSE_ERROR_INVALID_OFFSET                     = Bse::ERROR_INVALID_OFFSET,
+  BSE_ERROR_INVALID_DURATION                   = Bse::ERROR_INVALID_DURATION,
+  BSE_ERROR_INVALID_OVERLAP                    = Bse::ERROR_INVALID_OVERLAP,
 } BseErrorType;
 
 
diff --git a/bse/bseutils.hh b/bse/bseutils.hh
index 8f818dc..f2e0572 100644
--- a/bse/bseutils.hh
+++ b/bse/bseutils.hh
@@ -3,7 +3,6 @@
 #define __BSE_UTILS_H__
 
 #include <rapicorn-core.hh>
-#include <bse/bseserverapi.hh>
 
 #include <bse/bseenums.hh>
 #include <bse/bseglobals.hh>
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]