diff --git a/include/fluidsynth/settings.h b/include/fluidsynth/settings.h
index 9e0cb374..a040d09b 100644
--- a/include/fluidsynth/settings.h
+++ b/include/fluidsynth/settings.h
@@ -123,7 +123,7 @@ FLUIDSYNTH_API
 int fluid_settings_get_type(fluid_settings_t* settings, const char *name);
 
 FLUIDSYNTH_API
-int fluid_settings_get_hints(fluid_settings_t* settings, const char *name);
+int fluid_settings_get_hints(fluid_settings_t* settings, const char *name, int* val);
 
 FLUIDSYNTH_API
 int fluid_settings_is_realtime(fluid_settings_t* settings, const char *name);
@@ -150,10 +150,10 @@ FLUIDSYNTH_API
 int fluid_settings_getnum(fluid_settings_t* settings, const char *name, double* val);
 
 FLUIDSYNTH_API
-double fluid_settings_getnum_default(fluid_settings_t* settings, const char *name);
+int fluid_settings_getnum_default(fluid_settings_t* settings, const char *name, double* val);
 
 FLUIDSYNTH_API
-void fluid_settings_getnum_range(fluid_settings_t* settings, const char *name,
+int fluid_settings_getnum_range(fluid_settings_t* settings, const char *name,
 				double* min, double* max);
 
 FLUIDSYNTH_API
@@ -163,10 +163,10 @@ FLUIDSYNTH_API
 int fluid_settings_getint(fluid_settings_t* settings, const char *name, int* val);
 
 FLUIDSYNTH_API
-int fluid_settings_getint_default(fluid_settings_t* settings, const char *name);
+int fluid_settings_getint_default(fluid_settings_t* settings, const char *name, int* val);
 
 FLUIDSYNTH_API
-void fluid_settings_getint_range(fluid_settings_t* settings, const char *name,
+int fluid_settings_getint_range(fluid_settings_t* settings, const char *name,
 				int* min, int* max);
 
 /**
diff --git a/src/bindings/fluid_cmd.c b/src/bindings/fluid_cmd.c
index b817cc52..1a20320d 100644
--- a/src/bindings/fluid_cmd.c
+++ b/src/bindings/fluid_cmd.c
@@ -1298,15 +1298,14 @@ fluid_handle_set(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
       fluid_ostream_printf (out, "set: Parameter '%s' not found.\n", av[0]);
       break;
     case FLUID_INT_TYPE:
-      hints = fluid_settings_get_hints (synth->settings, av[0]);
-
-      if (hints & FLUID_HINT_TOGGLED)
+      if (fluid_settings_get_hints (synth->settings, av[0], &hints) == FLUID_OK
+          && hints & FLUID_HINT_TOGGLED)
       {
-        if (FLUID_STRCMP (av[1], "yes") == 0 || FLUID_STRCMP (av[1], "True") == 0
-            || FLUID_STRCMP (av[1], "TRUE") == 0 || FLUID_STRCMP (av[1], "true") == 0
-            || FLUID_STRCMP (av[1], "T") == 0)
+          if (FLUID_STRCMP (av[1], "yes") == 0 || FLUID_STRCMP (av[1], "True") == 0
+              || FLUID_STRCMP (av[1], "TRUE") == 0 || FLUID_STRCMP (av[1], "true") == 0
+              || FLUID_STRCMP (av[1], "T") == 0)
           ival = 1;
-        else ival = atoi (av[1]);
+          else ival = atoi (av[1]);
       }
       else ival = atoi (av[1]);
 
@@ -1407,11 +1406,13 @@ static void fluid_handle_settings_iter2(void* data, char* name, int type)
   case FLUID_INT_TYPE: {
     int value, hints;
     fluid_synth_getint(d->synth, name, &value);
-    hints = fluid_settings_get_hints (d->synth->settings, name);
-
-    if (!(hints & FLUID_HINT_TOGGLED))
-      fluid_ostream_printf(d->out, "%d\n", value);
-    else fluid_ostream_printf(d->out, "%s\n", value ? "True" : "False");
+    
+    if(fluid_settings_get_hints (d->synth->settings, name, &hints) == FLUID_OK)
+    {
+        if (!(hints & FLUID_HINT_TOGGLED))
+        fluid_ostream_printf(d->out, "%d\n", value);
+        else fluid_ostream_printf(d->out, "%s\n", value ? "True" : "False");
+    }
     break;
   }
 
@@ -1474,48 +1475,59 @@ fluid_handle_info(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
     return -1;
 
   case FLUID_NUM_TYPE: {
-    double value, min, max;
-    fluid_settings_getnum_range(settings, av[0], &min, &max);
-    fluid_settings_getnum(settings, av[0], &value);
-    fluid_ostream_printf(out, "%s:\n", av[0]);
-    fluid_ostream_printf(out, "Type:          number\n");
-    fluid_ostream_printf(out, "Value:         %.3f\n", value);
-    fluid_ostream_printf(out, "Minimum value: %.3f\n", min);
-    fluid_ostream_printf(out, "Maximum value: %.3f\n", max);
-    fluid_ostream_printf(out, "Default value: %.3f\n",
-			fluid_settings_getnum_default(settings, av[0]));
-    fluid_ostream_printf(out, "Real-time:     %s\n",
-			fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
+    double value, min, max, def;
+    if(fluid_settings_getnum_range(settings, av[0], &min, &max) == FLUID_OK
+       && fluid_settings_getnum(settings, av[0], &value) == FLUID_OK
+       && fluid_settings_getnum_default(settings, av[0], &def) == FLUID_OK)
+    {
+        fluid_ostream_printf(out, "%s:\n", av[0]);
+        fluid_ostream_printf(out, "Type:          number\n");
+        fluid_ostream_printf(out, "Value:         %.3f\n", value);
+        fluid_ostream_printf(out, "Minimum value: %.3f\n", min);
+        fluid_ostream_printf(out, "Maximum value: %.3f\n", max);
+        fluid_ostream_printf(out, "Default value: %.3f\n", def);
+        fluid_ostream_printf(out, "Real-time:     %s\n",
+                fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
+    }
+    else
+    {
+        fluid_ostream_printf(out, "An error occurred when processing %s\n", av[0]);
+    }
     break;
   }
 
   case FLUID_INT_TYPE: {
     int value, min, max, def, hints;
 
-    fluid_settings_getint_range(settings, av[0], &min, &max);
-    fluid_settings_getint(settings, av[0], &value);
-    hints = fluid_settings_get_hints(settings, av[0]);
-    def = fluid_settings_getint_default (settings, av[0]);
-
-    fluid_ostream_printf(out, "%s:\n", av[0]);
-
-    if (!(hints & FLUID_HINT_TOGGLED))
+    if(fluid_settings_getint_range(settings, av[0], &min, &max) == FLUID_OK
+       && fluid_settings_getint(settings, av[0], &value) == FLUID_OK
+       && fluid_settings_get_hints(settings, av[0], &hints) == FLUID_OK
+       && fluid_settings_getint_default (settings, av[0], &def) == FLUID_OK)
     {
-      fluid_ostream_printf(out, "Type:          integer\n");
-      fluid_ostream_printf(out, "Value:         %d\n", value);
-      fluid_ostream_printf(out, "Minimum value: %d\n", min);
-      fluid_ostream_printf(out, "Maximum value: %d\n", max);
-      fluid_ostream_printf(out, "Default value: %d\n", def);
+        fluid_ostream_printf(out, "%s:\n", av[0]);
+
+        if (!(hints & FLUID_HINT_TOGGLED))
+        {
+        fluid_ostream_printf(out, "Type:          integer\n");
+        fluid_ostream_printf(out, "Value:         %d\n", value);
+        fluid_ostream_printf(out, "Minimum value: %d\n", min);
+        fluid_ostream_printf(out, "Maximum value: %d\n", max);
+        fluid_ostream_printf(out, "Default value: %d\n", def);
+        }
+        else
+        {
+        fluid_ostream_printf(out, "Type:          boolean\n");
+        fluid_ostream_printf(out, "Value:         %s\n", value ? "True" : "False");
+        fluid_ostream_printf(out, "Default value: %s\n", def ? "True" : "False");
+        }
+
+        fluid_ostream_printf(out, "Real-time:     %s\n",
+                fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
     }
     else
     {
-      fluid_ostream_printf(out, "Type:          boolean\n");
-      fluid_ostream_printf(out, "Value:         %s\n", value ? "True" : "False");
-      fluid_ostream_printf(out, "Default value: %s\n", def ? "True" : "False");
+        fluid_ostream_printf(out, "An error occurred when processing %s\n", av[0]);
     }
-
-    fluid_ostream_printf(out, "Real-time:     %s\n",
-			fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
     break;
   }
 
diff --git a/src/fluidsynth.c b/src/fluidsynth.c
index 3d64666a..d3d202ab 100644
--- a/src/fluidsynth.c
+++ b/src/fluidsynth.c
@@ -111,9 +111,8 @@ void process_o_cmd_line_option(fluid_settings_t* settings, char* optarg)
     }
     break;
   case FLUID_INT_TYPE:
-    hints = fluid_settings_get_hints (settings, optarg);
-
-    if (hints & FLUID_HINT_TOGGLED)
+    if (fluid_settings_get_hints (settings, optarg, &hints) == FLUID_OK
+        && hints & FLUID_HINT_TOGGLED)
     {
       if (FLUID_STRCMP (val, "yes") == 0 || FLUID_STRCMP (val, "True") == 0
           || FLUID_STRCMP (val, "TRUE") == 0 || FLUID_STRCMP (val, "true") == 0
@@ -184,14 +183,14 @@ settings_foreach_func (void *data, char *name, int type)
   {
   case FLUID_NUM_TYPE:
     fluid_settings_getnum_range (settings, name, &dmin, &dmax);
-    ddef = fluid_settings_getnum_default (settings, name);
+    fluid_settings_getnum_default (settings, name, &ddef);
     printf ("%-24s FLOAT [min=%0.3f, max=%0.3f, def=%0.3f]\n",
 	    name, dmin, dmax, ddef);
     break;
   case FLUID_INT_TYPE:
     fluid_settings_getint_range (settings, name, &imin, &imax);
-    idef = fluid_settings_getint_default (settings, name);
-    hints = fluid_settings_get_hints (settings, name);
+    fluid_settings_getint_default (settings, name, &idef);
+    fluid_settings_get_hints (settings, name, &hints);
 
     if (!(hints & FLUID_HINT_TOGGLED))
     {
diff --git a/src/utils/fluid_settings.c b/src/utils/fluid_settings.c
index ae62a15d..99868d18 100644
--- a/src/utils/fluid_settings.c
+++ b/src/utils/fluid_settings.c
@@ -337,7 +337,7 @@ fluid_settings_tokenize(const char *s, char *buf, char **ptr)
  * @param settings a settings object
  * @param name Settings name
  * @param value Location to store setting node if found
- * @return 1 if the node exists, 0 otherwise
+ * @return #FLUID_OK if the node exists, #FLUID_FAILED otherwise
  */
 static int
 fluid_settings_get(fluid_settings_t* settings, const char *name,
@@ -352,19 +352,19 @@ fluid_settings_get(fluid_settings_t* settings, const char *name,
 
   ntokens = fluid_settings_tokenize (name, buf, tokens);
 
-  if (table == NULL || ntokens <= 0) return 0;
+  if (table == NULL || ntokens <= 0) return FLUID_FAILED;
 
   for (n = 0; n < ntokens; n++) {
 
     node = fluid_hashtable_lookup(table, tokens[n]);
-    if (!node) return 0;
+    if (!node) return FLUID_FAILED;
 
     table = (node->type == FLUID_SET_TYPE) ? ((fluid_set_setting_t *)node)->hashtable : NULL;
   }
 
   if (value) *value = node;
 
-  return 1;
+  return FLUID_OK;
 }
 
 /**
@@ -373,7 +373,7 @@ fluid_settings_get(fluid_settings_t* settings, const char *name,
  * @param settings a settings object
  * @param name Settings name
  * @param value Node instance to assign (used directly)
- * @return 1 if the value has been set, zero otherwise
+ * @return #FLUID_OK if the value has been set, #FLUID_FAILED otherwise
  */
 static int
 fluid_settings_set(fluid_settings_t* settings, const char *name, void* value)
@@ -387,7 +387,7 @@ fluid_settings_set(fluid_settings_t* settings, const char *name, void* value)
 
   num = fluid_settings_tokenize (name, buf, tokens) - 1;
   if (num == 0)
-    return 0;
+    return FLUID_FAILED;
 
   for (n = 0; n < num; n++) {
 
@@ -400,7 +400,7 @@ fluid_settings_set(fluid_settings_t* settings, const char *name, void* value)
       } else {
 	/* path ends prematurely */
 	FLUID_LOG(FLUID_WARN, "'%s' is not a node", name[n]);
-	return 0;
+	return FLUID_FAILED;
       }
 
     } else {
@@ -417,7 +417,7 @@ fluid_settings_set(fluid_settings_t* settings, const char *name, void* value)
 
         if (setnode) delete_fluid_set_setting (setnode);
 
-        return 0;
+        return FLUID_FAILED;
       }
 
       fluid_hashtable_insert(table, dupname, setnode);
@@ -430,34 +430,43 @@ fluid_settings_set(fluid_settings_t* settings, const char *name, void* value)
   if (!dupname)
   {
     FLUID_LOG(FLUID_ERR, "Out of memory");
-    return 0;
+    return FLUID_FAILED;
   }
 
   fluid_hashtable_insert(table, dupname, value);
 
-  return 1;
+  return FLUID_OK;
 }
 
-/** returns 1 if the value has been registered correctly, 0
-    otherwise */
+/**
+ * Registers a new string value for the specified setting.
+ * 
+ * @param settings a settings object
+ * @param name the setting's name
+ * @param def the default value for the setting
+ * @param hints the hints for the setting
+ * @param fun an update function for the setting
+ * @param data user supplied data
+ * @return #FLUID_OK if the value has been register correctly, #FLUID_FAILED otherwise
+ */
 int
 fluid_settings_register_str(fluid_settings_t* settings, const char* name, const char* def, int hints,
 			    fluid_str_update_t fun, void* data)
 {
   fluid_setting_node_t *node;
   fluid_str_setting_t* setting;
-  int retval;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
   if (!fluid_settings_get(settings, name, &node)) {
     setting = new_fluid_str_setting(def, def, hints, fun, data);
     retval = fluid_settings_set(settings, name, setting);
-    if (retval != 1) delete_fluid_str_setting (setting);
+    if (retval != FLUID_OK) delete_fluid_str_setting (setting);
   } else {
     /* if variable already exists, don't change its value. */
     if (node->type == FLUID_STR_TYPE) {
@@ -466,10 +475,9 @@ fluid_settings_register_str(fluid_settings_t* settings, const char* name, const
       setting->data = data;
       setting->def = def? FLUID_STRDUP(def) : NULL;
       setting->hints = hints;
-      retval = 1;
+      retval = FLUID_OK;
     } else {
       FLUID_LOG(FLUID_WARN, "Type mismatch on setting '%s'", name);
-      retval = 0;
     }
   }
 
@@ -478,19 +486,30 @@ fluid_settings_register_str(fluid_settings_t* settings, const char* name, const
   return retval;
 }
 
-/** returns 1 if the value has been register correctly, zero
-    otherwise */
+/**
+ * Registers a new float value for the specified setting.
+ * 
+ * @param settings a settings object
+ * @param name the setting's name
+ * @param def the default value for the setting
+ * @param min the smallest allowed value for the setting
+ * @param max the largest allowed value for the setting
+ * @param hints the hints for the setting
+ * @param fun an update function for the setting
+ * @param data user supplied data
+ * @return #FLUID_OK if the value has been register correctly, #FLUID_FAILED otherwise
+ */
 int
 fluid_settings_register_num(fluid_settings_t* settings, const char* name, double def,
 			    double min, double max, int hints,
 			    fluid_num_update_t fun, void* data)
 {
   fluid_setting_node_t *node;
-  int retval;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
 
   /* For now, all floating point settings are bounded below and above */
   hints |= FLUID_HINT_BOUNDED_BELOW | FLUID_HINT_BOUNDED_ABOVE;
@@ -502,7 +521,7 @@ fluid_settings_register_num(fluid_settings_t* settings, const char* name, double
     fluid_num_setting_t* setting;
     setting = new_fluid_num_setting(min, max, def, hints, fun, data);
     retval = fluid_settings_set(settings, name, setting);
-    if (retval != 1) delete_fluid_num_setting (setting);
+    if (retval != FLUID_OK) delete_fluid_num_setting (setting);
   } else {
     if (node->type == FLUID_NUM_TYPE) {
       /* update the existing setting but don't change its value */
@@ -513,11 +532,10 @@ fluid_settings_register_num(fluid_settings_t* settings, const char* name, double
       setting->max = max;
       setting->def = def;
       setting->hints = hints;
-      retval = 1;
+      retval = FLUID_OK;
     } else {
       /* type mismatch */
       FLUID_LOG(FLUID_WARN, "Type mismatch on setting '%s'", name);
-      retval = 0;
     }
   }
 
@@ -526,19 +544,30 @@ fluid_settings_register_num(fluid_settings_t* settings, const char* name, double
   return retval;
 }
 
-/** returns 1 if the value has been register correctly, zero
-    otherwise. */
+/**
+ * Registers a new integer value for the specified setting.
+ * 
+ * @param settings a settings object
+ * @param name the setting's name
+ * @param def the default value for the setting
+ * @param min the smallest allowed value for the setting
+ * @param max the largest allowed value for the setting
+ * @param hints the hints for the setting
+ * @param fun an update function for the setting
+ * @param data user supplied data
+ * @return #FLUID_OK if the value has been register correctly, #FLUID_FAILED otherwise
+ */
 int
 fluid_settings_register_int(fluid_settings_t* settings, const char* name, int def,
 			    int min, int max, int hints,
 			    fluid_int_update_t fun, void* data)
 {
   fluid_setting_node_t *node;
-  int retval;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
 
   /* For now, all integer settings are bounded below and above */
   hints |= FLUID_HINT_BOUNDED_BELOW | FLUID_HINT_BOUNDED_ABOVE;
@@ -550,7 +579,7 @@ fluid_settings_register_int(fluid_settings_t* settings, const char* name, int de
     fluid_int_setting_t* setting;
     setting = new_fluid_int_setting(min, max, def, hints, fun, data);
     retval = fluid_settings_set(settings, name, setting);
-    if (retval != 1) delete_fluid_int_setting (setting);
+    if (retval != FLUID_OK) delete_fluid_int_setting (setting);
   } else {
     if (node->type == FLUID_INT_TYPE) {
       /* update the existing setting but don't change its value */
@@ -561,11 +590,10 @@ fluid_settings_register_int(fluid_settings_t* settings, const char* name, int de
       setting->max = max;
       setting->def = def;
       setting->hints = hints;
-      retval = 1;
+      retval = FLUID_OK;
     } else {
       /* type mismatch */
       FLUID_LOG(FLUID_WARN, "Type mismatch on setting '%s'", name);
-      retval = 0;
     }
   }
 
@@ -581,21 +609,23 @@ fluid_settings_register_int(fluid_settings_t* settings, const char* name, int de
  * @param name a setting's name
  * @return the type for the named setting, or #FLUID_NO_TYPE when it does not exist
  */
-int
+enum fluid_types_enum
 fluid_settings_get_type(fluid_settings_t* settings, const char *name)
 {
   fluid_setting_node_t *node;
-  int type;
+  enum fluid_types_enum type = FLUID_NO_TYPE;
 
   fluid_return_val_if_fail (settings != NULL, FLUID_NO_TYPE);
   fluid_return_val_if_fail (name != NULL, FLUID_NO_TYPE);
   fluid_return_val_if_fail (name[0] != '\0', FLUID_NO_TYPE);
 
   fluid_rec_mutex_lock (settings->mutex);
-  type = fluid_settings_get (settings, name, &node) ? node->type : FLUID_NO_TYPE;
+  type = fluid_settings_get (settings, name, &node) == FLUID_OK
+         ? (enum fluid_types_enum)node->type
+         : FLUID_NO_TYPE;
   fluid_rec_mutex_unlock (settings->mutex);
 
-  return (type);
+  return type;
 }
 
 /**
@@ -603,36 +633,40 @@ fluid_settings_get_type(fluid_settings_t* settings, const char *name)
  *
  * @param settings a settings object
  * @param name a setting's name
- * @return the hints associated to the named setting if it exists, zero otherwise
+ * @param hints set to the hints associated to the setting if it exists
+ * @return #FLUID_OK if hints associated to the named setting exist, #FLUID_FAILED otherwise
  */
 int
-fluid_settings_get_hints(fluid_settings_t* settings, const char *name)
+fluid_settings_get_hints(fluid_settings_t* settings, const char *name, int* hints)
 {
   fluid_setting_node_t *node;
-  int hints = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)) {
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK) {
     if (node->type == FLUID_NUM_TYPE) {
       fluid_num_setting_t* setting = (fluid_num_setting_t*) node;
-      hints = setting->hints;
+      *hints = setting->hints;
+      retval = FLUID_OK;
     } else if (node->type == FLUID_STR_TYPE) {
       fluid_str_setting_t* setting = (fluid_str_setting_t*) node;
-      hints = setting->hints;
+      *hints = setting->hints;
+      retval = FLUID_OK;
     } else if (node->type == FLUID_INT_TYPE) {
       fluid_int_setting_t* setting = (fluid_int_setting_t*) node;
-      hints = setting->hints;
+      *hints = setting->hints;
+      retval = FLUID_OK;
     }
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
 
-  return hints;
+  return retval;
 }
 
 /**
@@ -640,7 +674,7 @@ fluid_settings_get_hints(fluid_settings_t* settings, const char *name)
  *
  * @param settings a settings object
  * @param name a setting's name
- * @return non zero if the setting is changeable in real-time
+ * @return TRUE if the setting is changeable in real-time, FALSE otherwise
  */
 int
 fluid_settings_is_realtime(fluid_settings_t* settings, const char *name)
@@ -654,7 +688,7 @@ fluid_settings_is_realtime(fluid_settings_t* settings, const char *name)
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)) {
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK) {
     if (node->type == FLUID_NUM_TYPE) {
       fluid_num_setting_t* setting = (fluid_num_setting_t*) node;
       isrealtime = setting->update != NULL;
@@ -678,21 +712,21 @@ fluid_settings_is_realtime(fluid_settings_t* settings, const char *name)
  * @param settings a settings object
  * @param name a setting's name
  * @param str new string value
- * @return 1 if the value has been set, 0 otherwise
+ * @return #FLUID_OK if the value has been set, #FLUID_FAILED otherwise
  */
 int
 fluid_settings_setstr(fluid_settings_t* settings, const char *name, const char *str)
 {
   fluid_setting_node_t *node;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get (settings, name, &node)) {
+  if (fluid_settings_get (settings, name, &node) == FLUID_OK) {
     if (node->type == FLUID_STR_TYPE) {
       fluid_str_setting_t *setting = (fluid_str_setting_t *)node;
 
@@ -701,7 +735,7 @@ fluid_settings_setstr(fluid_settings_t* settings, const char *name, const char *
 
       /* Call under lock to keep update() synchronized with the current value */
       if (setting->update) (*setting->update)(setting->data, name, str);
-      retval = 1;
+      retval = FLUID_OK;
     }
     else if (node->type == FLUID_INT_TYPE)      /* Handle yes/no for boolean values for backwards compatibility */
     {
@@ -713,11 +747,13 @@ fluid_settings_setstr(fluid_settings_t* settings, const char *name, const char *
         {
           setting->value = TRUE;
           if (setting->update) (*setting->update)(setting->data, name, TRUE);
+          retval = FLUID_OK;
         }
         else if (FLUID_STRCMP (str, "no") == 0)
         {
           setting->value = FALSE;
           if (setting->update) (*setting->update)(setting->data, name, FALSE);
+          retval = FLUID_OK;
         }
       }
     }
@@ -726,7 +762,7 @@ fluid_settings_setstr(fluid_settings_t* settings, const char *name, const char *
     fluid_str_setting_t* setting;
     setting = new_fluid_str_setting(str, NULL, 0, NULL, NULL);
     retval = fluid_settings_set(settings, name, setting);
-    if (retval != 1) delete_fluid_str_setting (setting);
+    if (retval != FLUID_OK) delete_fluid_str_setting (setting);
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
@@ -741,7 +777,7 @@ fluid_settings_setstr(fluid_settings_t* settings, const char *name, const char *
  * @param str Caller supplied buffer to copy string value to
  * @param len Size of 'str' buffer (no more than len bytes will be written, which
  *   will always include a zero terminator)
- * @return 1 if the value exists, 0 otherwise
+ * @return #FLUID_OK if the value exists, #FLUID_FAILED otherwise
  * @since 1.1.0
  *
  * @note A size of 256 should be more than sufficient for the string buffer.
@@ -751,19 +787,19 @@ fluid_settings_copystr(fluid_settings_t* settings, const char *name,
                        char *str, int len)
 {
   fluid_setting_node_t *node;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
-  fluid_return_val_if_fail (str != NULL, 0);
-  fluid_return_val_if_fail (len > 0, 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (str != NULL, retval);
+  fluid_return_val_if_fail (len > 0, retval);
 
   str[0] = 0;
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get (settings, name, &node))
+  if (fluid_settings_get (settings, name, &node) == FLUID_OK)
   {
     if (node->type == FLUID_STR_TYPE)
     {
@@ -775,7 +811,7 @@ fluid_settings_copystr(fluid_settings_t* settings, const char *name,
         str[len - 1] = 0;   /* Force terminate, in case of truncation */
       }
 
-      retval = 1;
+      retval = FLUID_OK;
     }
     else if (node->type == FLUID_INT_TYPE)      /* Handle boolean integers for backwards compatibility */
     {
@@ -786,7 +822,7 @@ fluid_settings_copystr(fluid_settings_t* settings, const char *name,
         FLUID_STRNCPY (str, setting->value ? "yes" : "no", len);
         str[len - 1] = 0;   /* Force terminate, in case of truncation */
 
-        retval = 1;
+        retval = FLUID_OK;
       }
     }
   }
@@ -801,7 +837,7 @@ fluid_settings_copystr(fluid_settings_t* settings, const char *name,
  * @param settings a settings object
  * @param name a setting's name
  * @param str Location to store pointer to allocated duplicate string
- * @return 1 if the value exists and was successfully duplicated, 0 otherwise
+ * @return #FLUID_OK if the value exists and was successfully duplicated, #FLUID_FAILED otherwise
  * @since 1.1.0
  *
  * Like fluid_settings_copystr() but allocates a new copy of the string.  Caller
@@ -811,16 +847,16 @@ int
 fluid_settings_dupstr(fluid_settings_t* settings, const char *name, char** str)
 {
   fluid_setting_node_t *node;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
-  fluid_return_val_if_fail (str != NULL, 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (str != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node))
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK)
   {
     if (node->type == FLUID_STR_TYPE)
     {
@@ -832,7 +868,7 @@ fluid_settings_dupstr(fluid_settings_t* settings, const char *name, char** str)
         if (!*str) FLUID_LOG (FLUID_ERR, "Out of memory");
       }
 
-      if (!setting->value || *str) retval = 1;    /* Don't set to 1 if out of memory */
+      if (!setting->value || *str) retval = FLUID_OK;    /* Don't set to FLUID_OK if out of memory */
     }
     else if (node->type == FLUID_INT_TYPE)      /* Handle boolean integers for backwards compatibility */
     {
@@ -843,7 +879,7 @@ fluid_settings_dupstr(fluid_settings_t* settings, const char *name, char** str)
         *str = FLUID_STRDUP (setting->value ? "yes" : "no");
         if (!*str) FLUID_LOG (FLUID_ERR, "Out of memory");
 
-        if (!setting->value || *str) retval = 1;    /* Don't set to 1 if out of memory */
+        if (!setting->value || *str) retval = FLUID_OK;    /* Don't set to FLUID_OK if out of memory */
       }
     }
   }
@@ -860,34 +896,43 @@ fluid_settings_dupstr(fluid_settings_t* settings, const char *name, char** str)
  * @param settings a settings object
  * @param name a setting's name
  * @param s a string to be tested
- * @return 1 if the value exists and is equal to 's', 0 otherwise
+ * @return #FLUID_OK if the value exists and is equal to 's', #FLUID_FAILED otherwise
  */
 int
 fluid_settings_str_equal (fluid_settings_t* settings, const char *name, const char *s)
 {
   fluid_setting_node_t *node;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
-  fluid_return_val_if_fail (s != NULL, 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (s != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get (settings, name, &node))
+  if (fluid_settings_get (settings, name, &node) == FLUID_OK)
   {
     if (node->type == FLUID_STR_TYPE)
     {
       fluid_str_setting_t *setting = (fluid_str_setting_t *)node;
-      if (setting->value) retval = FLUID_STRCMP (setting->value, s) == 0;
+      if (setting->value)
+      {
+          retval = FLUID_STRCMP (setting->value, s) == 0
+                   ? FLUID_OK
+                   : FLUID_FAILED;
+      }
     }
     else if (node->type == FLUID_INT_TYPE)      /* Handle boolean integers for backwards compatibility */
     {
       fluid_int_setting_t *setting = (fluid_int_setting_t *)node;
 
       if (setting->hints & FLUID_HINT_TOGGLED)
-        retval = FLUID_STRCMP (setting->value ? "yes" : "no", s) == 0;
+      {
+        retval = FLUID_STRCMP (setting->value ? "yes" : "no", s) == 0
+                 ? FLUID_OK
+                 : FLUID_FAILED;
+      }
     }
   }
 
@@ -916,7 +961,7 @@ fluid_settings_getstr_default(fluid_settings_t* settings, const char *name)
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get (settings, name, &node))
+  if (fluid_settings_get (settings, name, &node) == FLUID_OK)
   {
     if (node->type == FLUID_STR_TYPE)
     {
@@ -942,7 +987,7 @@ fluid_settings_getstr_default(fluid_settings_t* settings, const char *name)
  * @param settings a settings object
  * @param name a setting's name
  * @param s option string to add
- * @return 1 if the setting exists and option was added, 0 otherwise
+ * @return #FLUID_OK if the setting exists and option was added, #FLUID_FAILED otherwise
  *
  * Causes the setting's #FLUID_HINT_OPTIONLIST hint to be set.
  */
@@ -950,22 +995,22 @@ int
 fluid_settings_add_option(fluid_settings_t* settings, const char *name, const char *s)
 {
   fluid_setting_node_t *node;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
-  fluid_return_val_if_fail (s != NULL, 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (s != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK
       && (node->type == FLUID_STR_TYPE)) {
     fluid_str_setting_t* setting = (fluid_str_setting_t*) node;
     char* copy = FLUID_STRDUP(s);
     setting->options = fluid_list_append(setting->options, copy);
     setting->hints |= FLUID_HINT_OPTIONLIST;
-    retval = 1;
+    retval = FLUID_OK;
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
@@ -978,22 +1023,22 @@ fluid_settings_add_option(fluid_settings_t* settings, const char *name, const ch
  * @param settings a settings object
  * @param name a setting's name
  * @param s option string to remove
- * @return 1 if the setting exists and option was removed, 0 otherwise
+ * @return #FLUID_OK if the setting exists and option was removed, #FLUID_FAILED otherwise
  */
 int
 fluid_settings_remove_option(fluid_settings_t* settings, const char *name, const char* s)
 {
   fluid_setting_node_t *node;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
-  fluid_return_val_if_fail (s != NULL, 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (s != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK
       && (node->type == FLUID_STR_TYPE)) {
 
     fluid_str_setting_t* setting = (fluid_str_setting_t*) node;
@@ -1002,9 +1047,9 @@ fluid_settings_remove_option(fluid_settings_t* settings, const char *name, const
     while (list) {
       char* option = (char*) fluid_list_get(list);
       if (FLUID_STRCMP(s, option) == 0) {
-	FLUID_FREE (option);
-	setting->options = fluid_list_remove_link(setting->options, list);
-	retval = 1;
+        FLUID_FREE (option);
+        setting->options = fluid_list_remove_link(setting->options, list);
+        retval = FLUID_OK;
         break;
       }
       list = fluid_list_next(list);
@@ -1022,22 +1067,22 @@ fluid_settings_remove_option(fluid_settings_t* settings, const char *name, const
  * @param settings a settings object
  * @param name a setting's name
  * @param val new setting's value
- * @return 1 if the value has been set, 0 otherwise
+ * @return #FLUID_OK if the value has been set, #FLUID_FAILED otherwise
  */
 int
 fluid_settings_setnum(fluid_settings_t* settings, const char *name, double val)
 {
   fluid_setting_node_t *node;
   fluid_num_setting_t* setting;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)) {
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK) {
     if (node->type == FLUID_NUM_TYPE) {
       setting = (fluid_num_setting_t*) node;
 
@@ -1048,7 +1093,7 @@ fluid_settings_setnum(fluid_settings_t* settings, const char *name, double val)
 
       /* Call under lock to keep update() synchronized with the current value */
       if (setting->update) (*setting->update)(setting->data, name, val);
-      retval = 1;
+      retval = FLUID_OK;
     }
   } else {
     /* insert a new setting */
@@ -1056,7 +1101,7 @@ fluid_settings_setnum(fluid_settings_t* settings, const char *name, double val)
     setting = new_fluid_num_setting(-1e10, 1e10, 0.0f, 0, NULL, NULL);
     setting->value = val;
     retval = fluid_settings_set(settings, name, setting);
-    if (retval != 1) delete_fluid_num_setting (setting);
+    if (retval != FLUID_OK) delete_fluid_num_setting (setting);
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
@@ -1070,26 +1115,26 @@ fluid_settings_setnum(fluid_settings_t* settings, const char *name, double val)
  * @param settings a settings object
  * @param name a setting's name
  * @param val variable pointer to receive the setting's numeric value
- * @return 1 if the value exists, 0 otherwise
+ * @return #FLUID_OK if the value exists, #FLUID_FAILED otherwise
  */
 int
 fluid_settings_getnum(fluid_settings_t* settings, const char *name, double* val)
 {
   fluid_setting_node_t *node;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
-  fluid_return_val_if_fail (val != NULL, 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (val != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK
       && (node->type == FLUID_NUM_TYPE)) {
     fluid_num_setting_t* setting = (fluid_num_setting_t*) node;
     *val = setting->value;
-    retval = 1;
+    retval = FLUID_OK;
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
@@ -1104,29 +1149,34 @@ fluid_settings_getnum(fluid_settings_t* settings, const char *name, double* val)
  * @param name a setting's name
  * @param min setting's range lower limit
  * @param max setting's range upper limit
+ * @return #FLUID_OK if the setting's range exists, #FLUID_FAILED otherwise
  */
-void
+int
 fluid_settings_getnum_range(fluid_settings_t* settings, const char *name,
                             double* min, double* max)
 {
   fluid_setting_node_t *node;
+  int retval = FLUID_FAILED;
 
-  fluid_return_if_fail (settings != NULL);
-  fluid_return_if_fail (name != NULL);
-  fluid_return_if_fail (name[0] != '\0');
-  fluid_return_if_fail (min != NULL);
-  fluid_return_if_fail (max != NULL);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (min != NULL, retval);
+  fluid_return_val_if_fail (max != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK
       && (node->type == FLUID_NUM_TYPE)) {
     fluid_num_setting_t* setting = (fluid_num_setting_t*) node;
     *min = setting->min;
     *max = setting->max;
+    retval = FLUID_OK;
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
+  
+  return retval;
 }
 
 /**
@@ -1134,24 +1184,27 @@ fluid_settings_getnum_range(fluid_settings_t* settings, const char *name,
  *
  * @param settings a settings object
  * @param name a setting's name
- * @return the default value if the named setting exists, 0.0f otherwise
+ * @param val set to the default value if the named setting exists
+ * @return #FLUID_OK if the default value of the named setting exists, #FLUID_FAILED otherwise
  */
-double
-fluid_settings_getnum_default(fluid_settings_t* settings, const char *name)
+int
+fluid_settings_getnum_default(fluid_settings_t* settings, const char *name, double* val)
 {
   fluid_setting_node_t *node;
-  double retval = 0.0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0.0);
-  fluid_return_val_if_fail (name != NULL, 0.0);
-  fluid_return_val_if_fail (name[0] != '\0', 0.0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (val != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK
       && (node->type == FLUID_NUM_TYPE)) {
     fluid_num_setting_t* setting = (fluid_num_setting_t*) node;
-    retval = setting->def;
+    *val = setting->def;
+    retval = FLUID_OK;
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
@@ -1165,22 +1218,22 @@ fluid_settings_getnum_default(fluid_settings_t* settings, const char *name)
  * @param settings a settings object
  * @param name a setting's name
  * @param val new setting's integer value
- * @return 1 if the value has been set, 0 otherwise
+ * @return #FLUID_OK if the value has been set, #FLUID_FAILED otherwise
  */
 int
 fluid_settings_setint(fluid_settings_t* settings, const char *name, int val)
 {
   fluid_setting_node_t *node;
   fluid_int_setting_t* setting;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)) {
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK) {
     if (node->type == FLUID_INT_TYPE) {
       setting = (fluid_int_setting_t*) node;
 
@@ -1191,7 +1244,7 @@ fluid_settings_setint(fluid_settings_t* settings, const char *name, int val)
 
       /* Call under lock to keep update() synchronized with the current value */
       if (setting->update) (*setting->update)(setting->data, name, val);
-      retval = 1;
+      retval = FLUID_OK;
     }
   } else {
     /* insert a new setting */
@@ -1199,7 +1252,7 @@ fluid_settings_setint(fluid_settings_t* settings, const char *name, int val)
     setting = new_fluid_int_setting(INT_MIN, INT_MAX, 0, 0, NULL, NULL);
     setting->value = val;
     retval = fluid_settings_set(settings, name, setting);
-    if (retval != 1) delete_fluid_int_setting (setting);
+    if (retval != FLUID_OK) delete_fluid_int_setting (setting);
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
@@ -1213,26 +1266,26 @@ fluid_settings_setint(fluid_settings_t* settings, const char *name, int val)
  * @param settings a settings object
  * @param name a setting's name
  * @param val pointer to a variable to receive the setting's integer value
- * @return 1 if the value exists, 0 otherwise
+ * @return #FLUID_OK if the value exists, #FLUID_FAILED otherwise
  */
 int
 fluid_settings_getint(fluid_settings_t* settings, const char *name, int* val)
 {
   fluid_setting_node_t *node;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
-  fluid_return_val_if_fail (val != NULL, 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (val != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK
       && (node->type == FLUID_INT_TYPE)) {
     fluid_int_setting_t* setting = (fluid_int_setting_t*) node;
     *val = setting->value;
-    retval = 1;
+    retval = FLUID_OK;
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
@@ -1246,29 +1299,34 @@ fluid_settings_getint(fluid_settings_t* settings, const char *name, int* val)
  * @param name a setting's name
  * @param min setting's range lower limit
  * @param max setting's range upper limit
+ * @return #FLUID_OK if the setting's range exists, #FLUID_FAILED otherwise
  */
-void
+int
 fluid_settings_getint_range(fluid_settings_t* settings, const char *name,
                             int* min, int* max)
 {
   fluid_setting_node_t *node;
+  int retval = FLUID_FAILED;
 
-  fluid_return_if_fail (settings != NULL);
-  fluid_return_if_fail (name != NULL);
-  fluid_return_if_fail (name[0] != '\0');
-  fluid_return_if_fail (min != NULL);
-  fluid_return_if_fail (max != NULL);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (min != NULL, retval);
+  fluid_return_val_if_fail (max != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK
       && (node->type == FLUID_INT_TYPE)) {
     fluid_int_setting_t* setting = (fluid_int_setting_t*) node;
     *min = setting->min;
     *max = setting->max;
+    retval = FLUID_OK;
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
+  
+  return retval;
 }
 
 /**
@@ -1276,24 +1334,26 @@ fluid_settings_getint_range(fluid_settings_t* settings, const char *name,
  *
  * @param settings a settings object
  * @param name a setting's name
- * @return the setting's default integer value it it exists, zero otherwise
+ * @param val set to the setting's default integer value if it exists
+ * @return #FLUID_OK if the setting's default integer value exists, #FLUID_FAILED otherwise
  */
-int
-fluid_settings_getint_default(fluid_settings_t* settings, const char *name)
+int fluid_settings_getint_default(fluid_settings_t* settings, const char *name, int* val)
 {
   fluid_setting_node_t *node;
-  int retval = 0;
+  int retval = FLUID_FAILED;
 
-  fluid_return_val_if_fail (settings != NULL, 0);
-  fluid_return_val_if_fail (name != NULL, 0);
-  fluid_return_val_if_fail (name[0] != '\0', 0);
+  fluid_return_val_if_fail (settings != NULL, retval);
+  fluid_return_val_if_fail (name != NULL, retval);
+  fluid_return_val_if_fail (name[0] != '\0', retval);
+  fluid_return_val_if_fail (val != NULL, retval);
 
   fluid_rec_mutex_lock (settings->mutex);
 
-  if (fluid_settings_get(settings, name, &node)
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK
       && (node->type == FLUID_INT_TYPE)) {
     fluid_int_setting_t* setting = (fluid_int_setting_t*) node;
-    retval = setting->def;
+    *val = setting->def;
+    retval = FLUID_OK;
   }
 
   fluid_rec_mutex_unlock (settings->mutex);
@@ -1328,7 +1388,8 @@ fluid_settings_foreach_option (fluid_settings_t* settings, const char *name,
 
   fluid_rec_mutex_lock (settings->mutex);       /* ++ lock */
 
-  if (!fluid_settings_get (settings, name, &node) || node->type != FLUID_STR_TYPE)
+  if (fluid_settings_get (settings, name, &node) != FLUID_OK
+      || node->type != FLUID_STR_TYPE)
   {
     fluid_rec_mutex_unlock (settings->mutex);   /* -- unlock */
     return;
@@ -1370,7 +1431,8 @@ fluid_settings_option_count (fluid_settings_t *settings, const char *name)
   fluid_return_val_if_fail (name[0] != '\0', -1);
 
   fluid_rec_mutex_lock (settings->mutex);
-  if (fluid_settings_get(settings, name, &node) && node->type == FLUID_STR_TYPE)
+  if (fluid_settings_get(settings, name, &node) == FLUID_OK
+      && node->type == FLUID_STR_TYPE)
     count = fluid_list_size (((fluid_str_setting_t *)node)->options);
   fluid_rec_mutex_unlock (settings->mutex);
 
@@ -1404,7 +1466,8 @@ fluid_settings_option_concat (fluid_settings_t *settings, const char *name,
 
   fluid_rec_mutex_lock (settings->mutex);       /* ++ lock */
 
-  if (!fluid_settings_get (settings, name, &node) || node->type != FLUID_STR_TYPE)
+  if (fluid_settings_get (settings, name, &node) != FLUID_OK
+      || node->type != FLUID_STR_TYPE)
   {
     fluid_rec_mutex_unlock (settings->mutex);   /* -- unlock */
     return (NULL);
@@ -1514,7 +1577,6 @@ fluid_settings_foreach (fluid_settings_t* settings, void* data,
   fluid_settings_foreach_bag_t bag;
   fluid_setting_node_t *node;
   fluid_list_t *p;
-  int r;
 
   fluid_return_if_fail (settings != NULL);
   fluid_return_if_fail (func != NULL);
@@ -1533,8 +1595,9 @@ fluid_settings_foreach (fluid_settings_t* settings, void* data,
   /* Loop over names and call the callback */
   for (p = bag.names; p; p = p->next)
   {
-    r = fluid_settings_get (settings, (char *)(p->data), &node);
-    if (r && node) (*func) (data, (char *)(p->data), node->type);
+    if (fluid_settings_get (settings, (char *)(p->data), &node) == FLUID_OK
+        && node)
+        (*func) (data, (char *)(p->data), node->type);
     FLUID_FREE (p->data);       /* -- Free name */
   }