diff libpurple/prefs.c @ 15822:32c366eeeb99

sed -ie 's/gaim/purple/g'

--- a/libpurple/prefs.c	Mon Mar 19 06:11:46 2007 +0000
+++ b/libpurple/prefs.c	Mon Mar 19 07:01:17 2007 +0000
@@ -1,7 +1,7 @@
 /*
- * gaim
+ * purple
  *
- * Gaim is the legal property of its developers, whose names are too numerous
+ * Purple is the legal property of its developers, whose names are too numerous
  * to list here.  Please refer to the COPYRIGHT file distributed with this
  * source distribution.
  *
@@ -41,15 +41,15 @@
 #endif
 
 struct pref_cb {
-	GaimPrefCallback func;
+	PurplePrefCallback func;
 	gpointer data;
 	guint id;
 	void *handle;
 };
 
-/* TODO: This should use GaimValues? */
-struct gaim_pref {
-	GaimPrefType type;
+/* TODO: This should use PurpleValues? */
+struct purple_pref {
+	PurplePrefType type;
 	char *name;
 	union {
 		gpointer generic;
@@ -59,14 +59,14 @@
 		GList *stringlist;
 	} value;
 	GSList *callbacks;
-	struct gaim_pref *parent;
-	struct gaim_pref *sibling;
-	struct gaim_pref *first_child;
+	struct purple_pref *parent;
+	struct purple_pref *sibling;
+	struct purple_pref *first_child;
 };
 
 
-static struct gaim_pref prefs = {
-	GAIM_PREF_NONE,
+static struct purple_pref prefs = {
+	PURPLE_PREF_NONE,
 	NULL,
 	{ NULL },
 	NULL,
@@ -85,7 +85,7 @@
  *********************************************************************/
 
 static struct
-gaim_pref *find_pref(const char *name)
+purple_pref *find_pref(const char *name)
 {
 	if (!name || name[0] != '/')
 		return NULL;
@@ -105,10 +105,10 @@
  * tree structure.  Yay recursion!
  */
 static void
-pref_to_xmlnode(xmlnode *parent, struct gaim_pref *pref)
+pref_to_xmlnode(xmlnode *parent, struct purple_pref *pref)
 {
 	xmlnode *node, *childnode;
-	struct gaim_pref *child;
+	struct purple_pref *child;
 	char buf[20];
 	GList *cur;
 
@@ -116,17 +116,17 @@
 	node = xmlnode_new_child(parent, "pref");
 	xmlnode_set_attrib(node, "name", pref->name);
 
-	/* Set the type of this node (if type == GAIM_PREF_NONE then do nothing) */
-	if (pref->type == GAIM_PREF_INT) {
+	/* Set the type of this node (if type == PURPLE_PREF_NONE then do nothing) */
+	if (pref->type == PURPLE_PREF_INT) {
 		xmlnode_set_attrib(node, "type", "int");
 		snprintf(buf, sizeof(buf), "%d", pref->value.integer);
 		xmlnode_set_attrib(node, "value", buf);
 	}
-	else if (pref->type == GAIM_PREF_STRING) {
+	else if (pref->type == PURPLE_PREF_STRING) {
 		xmlnode_set_attrib(node, "type", "string");
 		xmlnode_set_attrib(node, "value", pref->value.string ? pref->value.string : "");
 	}
-	else if (pref->type == GAIM_PREF_STRING_LIST) {
+	else if (pref->type == PURPLE_PREF_STRING_LIST) {
 		xmlnode_set_attrib(node, "type", "stringlist");
 		for (cur = pref->value.stringlist; cur != NULL; cur = cur->next)
 		{
@@ -134,13 +134,13 @@
 			xmlnode_set_attrib(childnode, "value", cur->data ? cur->data : "");
 		}
 	}
-	else if (pref->type == GAIM_PREF_PATH) {
+	else if (pref->type == PURPLE_PREF_PATH) {
 		char *encoded = g_filename_to_utf8(pref->value.string ? pref->value.string : "", -1, NULL, NULL, NULL);
 		xmlnode_set_attrib(node, "type", "path");
 		xmlnode_set_attrib(node, "value", encoded);
 		g_free(encoded);
 	}
-	else if (pref->type == GAIM_PREF_PATH_LIST) {
+	else if (pref->type == PURPLE_PREF_PATH_LIST) {
 		xmlnode_set_attrib(node, "type", "pathlist");
 		for (cur = pref->value.stringlist; cur != NULL; cur = cur->next)
 		{
@@ -150,7 +150,7 @@
 			g_free(encoded);
 		}
 	}
-	else if (pref->type == GAIM_PREF_BOOLEAN) {
+	else if (pref->type == PURPLE_PREF_BOOLEAN) {
 		xmlnode_set_attrib(node, "type", "bool");
 		snprintf(buf, sizeof(buf), "%d", pref->value.boolean);
 		xmlnode_set_attrib(node, "value", buf);
@@ -165,7 +165,7 @@
 prefs_to_xmlnode(void)
 {
 	xmlnode *node;
-	struct gaim_pref *pref, *child;
+	struct purple_pref *pref, *child;
 
 	pref = &prefs;
 
@@ -191,16 +191,16 @@
 	{
 		/*
 		 * TODO: Call schedule_prefs_save()?  Ideally we wouldn't need to.
-		 * (prefs.xml should be loaded when gaim_prefs_init is called)
+		 * (prefs.xml should be loaded when purple_prefs_init is called)
 		 */
-		gaim_debug_error("prefs", "Attempted to save prefs before "
+		purple_debug_error("prefs", "Attempted to save prefs before "
 						 "they were read!\n");
 		return;
 	}
 
 	node = prefs_to_xmlnode();
 	data = xmlnode_to_formatted_str(node, NULL);
-	gaim_util_write_data_to_file("prefs.xml", data, -1);
+	purple_util_write_data_to_file("prefs.xml", data, -1);
 	g_free(data);
 	xmlnode_free(node);
 }
@@ -217,7 +217,7 @@
 schedule_prefs_save(void)
 {
 	if (save_timer == 0)
-		save_timer = gaim_timeout_add(5000, save_cb, NULL);
+		save_timer = purple_timeout_add(5000, save_cb, NULL);
 }
 
 
@@ -235,7 +235,7 @@
 		gpointer user_data,
 		GError **error)
 {
-	GaimPrefType pref_type = GAIM_PREF_NONE;
+	PurplePrefType pref_type = PURPLE_PREF_NONE;
 	int i;
 	const char *pref_name = NULL, *pref_value = NULL;
 	GString *pref_name_full;
@@ -249,17 +249,17 @@
 			pref_name = attribute_values[i];
 		} else if(!strcmp(attribute_names[i], "type")) {
 			if(!strcmp(attribute_values[i], "bool"))
-				pref_type = GAIM_PREF_BOOLEAN;
+				pref_type = PURPLE_PREF_BOOLEAN;
 			else if(!strcmp(attribute_values[i], "int"))
-				pref_type = GAIM_PREF_INT;
+				pref_type = PURPLE_PREF_INT;
 			else if(!strcmp(attribute_values[i], "string"))
-				pref_type = GAIM_PREF_STRING;
+				pref_type = PURPLE_PREF_STRING;
 			else if(!strcmp(attribute_values[i], "stringlist"))
-				pref_type = GAIM_PREF_STRING_LIST;
+				pref_type = PURPLE_PREF_STRING_LIST;
 			else if(!strcmp(attribute_values[i], "path"))
-				pref_type = GAIM_PREF_PATH;
+				pref_type = PURPLE_PREF_PATH;
 			else if(!strcmp(attribute_values[i], "pathlist"))
-				pref_type = GAIM_PREF_PATH_LIST;
+				pref_type = PURPLE_PREF_PATH_LIST;
 			else
 				return;
 		} else if(!strcmp(attribute_names[i], "value")) {
@@ -268,7 +268,7 @@
 	}
 
 	if(!strcmp(element_name, "item")) {
-		struct gaim_pref *pref;
+		struct purple_pref *pref;
 
 		pref_name_full = g_string_new("");
 
@@ -280,10 +280,10 @@
 		pref = find_pref(pref_name_full->str);
 
 		if(pref) {
-			if(pref->type == GAIM_PREF_STRING_LIST) {
+			if(pref->type == PURPLE_PREF_STRING_LIST) {
 				pref->value.stringlist = g_list_append(pref->value.stringlist,
 						g_strdup(pref_value));
-			} else if(pref->type == GAIM_PREF_PATH_LIST) {
+			} else if(pref->type == PURPLE_PREF_PATH_LIST) {
 				pref->value.stringlist = g_list_append(pref->value.stringlist,
 						g_filename_from_utf8(pref_value, -1, NULL, NULL, NULL));
 			}
@@ -304,28 +304,28 @@
 		pref_name_full = g_string_prepend_c(pref_name_full, '/');
 
 		switch(pref_type) {
-			case GAIM_PREF_NONE:
-				gaim_prefs_add_none(pref_name_full->str);
+			case PURPLE_PREF_NONE:
+				purple_prefs_add_none(pref_name_full->str);
 				break;
-			case GAIM_PREF_BOOLEAN:
-				gaim_prefs_set_bool(pref_name_full->str, atoi(pref_value));
+			case PURPLE_PREF_BOOLEAN:
+				purple_prefs_set_bool(pref_name_full->str, atoi(pref_value));
 				break;
-			case GAIM_PREF_INT:
-				gaim_prefs_set_int(pref_name_full->str, atoi(pref_value));
+			case PURPLE_PREF_INT:
+				purple_prefs_set_int(pref_name_full->str, atoi(pref_value));
 				break;
-			case GAIM_PREF_STRING:
-				gaim_prefs_set_string(pref_name_full->str, pref_value);
+			case PURPLE_PREF_STRING:
+				purple_prefs_set_string(pref_name_full->str, pref_value);
 				break;
-			case GAIM_PREF_STRING_LIST:
-				gaim_prefs_set_string_list(pref_name_full->str, NULL);
+			case PURPLE_PREF_STRING_LIST:
+				purple_prefs_set_string_list(pref_name_full->str, NULL);
 				break;
-			case GAIM_PREF_PATH:
+			case PURPLE_PREF_PATH:
 				decoded = g_filename_from_utf8(pref_value, -1, NULL, NULL, NULL);
-				gaim_prefs_set_path(pref_name_full->str, decoded);
+				purple_prefs_set_path(pref_name_full->str, decoded);
 				g_free(decoded);
 				break;
-			case GAIM_PREF_PATH_LIST:
-				gaim_prefs_set_path_list(pref_name_full->str, NULL);
+			case PURPLE_PREF_PATH_LIST:
+				purple_prefs_set_path_list(pref_name_full->str, NULL);
 				break;
 		}
 		prefs_stack = g_list_prepend(prefs_stack, g_strdup(pref_name));
@@ -353,9 +353,9 @@
 };
 
 gboolean
-gaim_prefs_load()
+purple_prefs_load()
 {
-	gchar *filename = g_build_filename(gaim_user_dir(), "prefs.xml", NULL);
+	gchar *filename = g_build_filename(purple_user_dir(), "prefs.xml", NULL);
 	gchar *contents = NULL;
 	gsize length;
 	GMarkupParseContext *context;
@@ -366,7 +366,7 @@
 		return FALSE;
 	}
 
-	gaim_debug_info("prefs", "Reading %s\n", filename);
+	purple_debug_info("prefs", "Reading %s\n", filename);
 
 	if(!g_file_get_contents(filename, &contents, &length, &error)) {
 #ifndef _WIN32
@@ -375,12 +375,12 @@
 
 		error = NULL;
 
-		filename = g_build_filename(SYSCONFDIR, "gaim", "prefs.xml", NULL);
+		filename = g_build_filename(SYSCONFDIR, "purple", "prefs.xml", NULL);
 
-		gaim_debug_info("prefs", "Reading %s\n", filename);
+		purple_debug_info("prefs", "Reading %s\n", filename);
 
 		if (!g_file_get_contents(filename, &contents, &length, &error)) {
-			gaim_debug_error("prefs", "Error reading prefs: %s\n",
+			purple_debug_error("prefs", "Error reading prefs: %s\n",
 					error->message);
 			g_error_free(error);
 			g_free(filename);
@@ -389,7 +389,7 @@
 			return FALSE;
 		}
 #else /* _WIN32 */
-		gaim_debug_error("prefs", "Error reading prefs: %s\n",
+		purple_debug_error("prefs", "Error reading prefs: %s\n",
 				error->message);
 		g_error_free(error);
 		g_free(filename);
@@ -411,7 +411,7 @@
 	}
 
 	if(!g_markup_parse_context_end_parse(context, NULL)) {
-		gaim_debug_error("prefs", "Error parsing %s\n", filename);
+		purple_debug_error("prefs", "Error parsing %s\n", filename);
 		g_markup_parse_context_free(context);
 		g_free(contents);
 		g_free(filename);
@@ -420,7 +420,7 @@
 		return FALSE;
 	}
 
-	gaim_debug_info("prefs", "Finished reading %s\n", filename);
+	purple_debug_info("prefs", "Finished reading %s\n", filename);
 	g_markup_parse_context_free(context);
 	g_free(contents);
 	g_free(filename);
@@ -429,14 +429,14 @@
 	/* I introduced a bug in 2.0.0beta2.  This fixes the broken
 	 * scores on upgrade.  This can be removed sometime shortly
 	 * after 2.0.0 final is released. -- rlaager */
-	if (gaim_prefs_get_int("/core/status/scores/offline") == -500 &&
-	    gaim_prefs_get_int("/core/status/scores/available") == 100 &&
-	    gaim_prefs_get_int("/core/status/scores/invisible") == -50 &&
-	    gaim_prefs_get_int("/core/status/scores/away") == -100 &&
-	    gaim_prefs_get_int("/core/status/scores/extended_away") == -200 &&
-	    gaim_prefs_get_int("/core/status/scores/idle") == -400)
+	if (purple_prefs_get_int("/core/status/scores/offline") == -500 &&
+	    purple_prefs_get_int("/core/status/scores/available") == 100 &&
+	    purple_prefs_get_int("/core/status/scores/invisible") == -50 &&
+	    purple_prefs_get_int("/core/status/scores/away") == -100 &&
+	    purple_prefs_get_int("/core/status/scores/extended_away") == -200 &&
+	    purple_prefs_get_int("/core/status/scores/idle") == -400)
 	{
-		gaim_prefs_set_int("/core/status/scores/idle", -10);
+		purple_prefs_set_int("/core/status/scores/idle", -10);
 	}
 
 	return TRUE;
@@ -445,14 +445,14 @@
 
 
 static void
-prefs_save_cb(const char *name, GaimPrefType type, gconstpointer val,
+prefs_save_cb(const char *name, PurplePrefType type, gconstpointer val,
 			  gpointer user_data)
 {
 
 	if(!prefs_loaded)
 		return;
 
-	gaim_debug_misc("prefs", "%s changed, scheduling save.\n", name);
+	purple_debug_misc("prefs", "%s changed, scheduling save.\n", name);
 
 	schedule_prefs_save();
 }
@@ -494,10 +494,10 @@
 }
 
 static char *
-pref_full_name(struct gaim_pref *pref)
+pref_full_name(struct purple_pref *pref)
 {
 	GString *name;
-	struct gaim_pref *parent;
+	struct purple_pref *parent;
 
 	if(!pref)
 		return NULL;
@@ -516,11 +516,11 @@
 	return g_string_free(name, FALSE);
 }
 
-static struct gaim_pref *
+static struct purple_pref *
 find_pref_parent(const char *name)
 {
 	char *parent_name = get_path_dirname(name);
-	struct gaim_pref *ret = &prefs;
+	struct purple_pref *ret = &prefs;
 
 	if(strcmp(parent_name, "/")) {
 		ret = find_pref(parent_name);
@@ -531,37 +531,37 @@
 }
 
 static void
-free_pref_value(struct gaim_pref *pref)
+free_pref_value(struct purple_pref *pref)
 {
 	switch(pref->type) {
-		case GAIM_PREF_BOOLEAN:
+		case PURPLE_PREF_BOOLEAN:
 			pref->value.boolean = FALSE;
 			break;
-		case GAIM_PREF_INT:
+		case PURPLE_PREF_INT:
 			pref->value.integer = 0;
 			break;
-		case GAIM_PREF_STRING:
-		case GAIM_PREF_PATH:
+		case PURPLE_PREF_STRING:
+		case PURPLE_PREF_PATH:
 			g_free(pref->value.string);
 			pref->value.string = NULL;
 			break;
-		case GAIM_PREF_STRING_LIST:
-		case GAIM_PREF_PATH_LIST:
+		case PURPLE_PREF_STRING_LIST:
+		case PURPLE_PREF_PATH_LIST:
 			{
 				g_list_foreach(pref->value.stringlist, (GFunc)g_free, NULL);
 				g_list_free(pref->value.stringlist);
 			} break;
-		case GAIM_PREF_NONE:
+		case PURPLE_PREF_NONE:
 			break;
 	}
 }
 
-static struct gaim_pref *
-add_pref(GaimPrefType type, const char *name)
+static struct purple_pref *
+add_pref(PurplePrefType type, const char *name)
 {
-	struct gaim_pref *parent;
-	struct gaim_pref *me;
-	struct gaim_pref *sibling;
+	struct purple_pref *parent;
+	struct purple_pref *me;
+	struct purple_pref *sibling;
 	char *my_name;
 
 	parent = find_pref_parent(name);
@@ -578,7 +578,7 @@
 		}
 	}
 
-	me = g_new0(struct gaim_pref, 1);
+	me = g_new0(struct purple_pref, 1);
 	me->type = type;
 	me->name = my_name;
 
@@ -598,15 +598,15 @@
 }
 
 void
-gaim_prefs_add_none(const char *name)
+purple_prefs_add_none(const char *name)
 {
-	add_pref(GAIM_PREF_NONE, name);
+	add_pref(PURPLE_PREF_NONE, name);
 }
 
 void
-gaim_prefs_add_bool(const char *name, gboolean value)
+purple_prefs_add_bool(const char *name, gboolean value)
 {
-	struct gaim_pref *pref = add_pref(GAIM_PREF_BOOLEAN, name);
+	struct purple_pref *pref = add_pref(PURPLE_PREF_BOOLEAN, name);
 
 	if(!pref)
 		return;
@@ -615,9 +615,9 @@
 }
 
 void
-gaim_prefs_add_int(const char *name, int value)
+purple_prefs_add_int(const char *name, int value)
 {
-	struct gaim_pref *pref = add_pref(GAIM_PREF_INT, name);
+	struct purple_pref *pref = add_pref(PURPLE_PREF_INT, name);
 
 	if(!pref)
 		return;
@@ -626,16 +626,16 @@
 }
 
 void
-gaim_prefs_add_string(const char *name, const char *value)
+purple_prefs_add_string(const char *name, const char *value)
 {
-	struct gaim_pref *pref;
+	struct purple_pref *pref;
 
 	if(value != NULL && !g_utf8_validate(value, -1, NULL)) {
-		gaim_debug_error("prefs", "gaim_prefs_add_string: Cannot store invalid UTF8 for string pref %s\n", name);
+		purple_debug_error("prefs", "purple_prefs_add_string: Cannot store invalid UTF8 for string pref %s\n", name);
 		return;
 	}
 
-	pref = add_pref(GAIM_PREF_STRING, name);
+	pref = add_pref(PURPLE_PREF_STRING, name);
 
 	if(!pref)
 		return;
@@ -644,9 +644,9 @@
 }
 
 void
-gaim_prefs_add_string_list(const char *name, GList *value)
+purple_prefs_add_string_list(const char *name, GList *value)
 {
-	struct gaim_pref *pref = add_pref(GAIM_PREF_STRING_LIST, name);
+	struct purple_pref *pref = add_pref(PURPLE_PREF_STRING_LIST, name);
 	GList *tmp;
 
 	if(!pref)
@@ -654,7 +654,7 @@
 
 	for(tmp = value; tmp; tmp = tmp->next) {
 		if(tmp->data != NULL && !g_utf8_validate(tmp->data, -1, NULL)) {
-			gaim_debug_error("prefs", "gaim_prefs_add_string_list: Skipping invalid UTF8 for string list pref %s\n", name);
+			purple_debug_error("prefs", "purple_prefs_add_string_list: Skipping invalid UTF8 for string list pref %s\n", name);
 			continue;
 		}
 		pref->value.stringlist = g_list_append(pref->value.stringlist,
@@ -663,9 +663,9 @@
 }
 
 void
-gaim_prefs_add_path(const char *name, const char *value)
+purple_prefs_add_path(const char *name, const char *value)
 {
-	struct gaim_pref *pref = add_pref(GAIM_PREF_PATH, name);
+	struct purple_pref *pref = add_pref(PURPLE_PREF_PATH, name);
 
 	if(!pref)
 		return;
@@ -674,9 +674,9 @@
 }
 
 void
-gaim_prefs_add_path_list(const char *name, GList *value)
+purple_prefs_add_path_list(const char *name, GList *value)
 {
-	struct gaim_pref *pref = add_pref(GAIM_PREF_PATH_LIST, name);
+	struct purple_pref *pref = add_pref(PURPLE_PREF_PATH_LIST, name);
 	GList *tmp;
 
 	if(!pref)
@@ -689,7 +689,7 @@
 
 
 static void
-remove_pref(struct gaim_pref *pref)
+remove_pref(struct purple_pref *pref)
 {
 	char *name;
 	GSList *l;
@@ -703,7 +703,7 @@
 	if(pref->parent->first_child == pref) {
 		pref->parent->first_child = pref->sibling;
 	} else {
-		struct gaim_pref *sib = pref->parent->first_child;
+		struct purple_pref *sib = pref->parent->first_child;
 		while(sib && sib->sibling != pref)
 			sib = sib->sibling;
 		if(sib)
@@ -712,7 +712,7 @@
 
 	name = pref_full_name(pref);
 
-	gaim_debug_info("prefs", "removing pref %s\n", name);
+	purple_debug_info("prefs", "removing pref %s\n", name);
 
 	g_hash_table_remove(prefs_hash, name);
 	g_free(name);
@@ -729,9 +729,9 @@
 }
 
 void
-gaim_prefs_remove(const char *name)
+purple_prefs_remove(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(!pref)
 		return;
@@ -740,16 +740,16 @@
 }
 
 void
-gaim_prefs_destroy()
+purple_prefs_destroy()
 {
-	gaim_prefs_remove("/");
+	purple_prefs_remove("/");
 }
 
 static void
-do_callbacks(const char* name, struct gaim_pref *pref)
+do_callbacks(const char* name, struct purple_pref *pref)
 {
 	GSList *cbs;
-	struct gaim_pref *cb_pref;
+	struct purple_pref *cb_pref;
 	for(cb_pref = pref; cb_pref; cb_pref = cb_pref->parent) {
 		for(cbs = cb_pref->callbacks; cbs; cbs = cbs->next) {
 			struct pref_cb *cb = cbs->data;
@@ -759,13 +759,13 @@
 }
 
 void
-gaim_prefs_trigger_callback(const char *name)
+purple_prefs_trigger_callback(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(!pref) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_trigger_callback: Unknown pref %s\n", name);
+		purple_debug_error("prefs",
+				"purple_prefs_trigger_callback: Unknown pref %s\n", name);
 		return;
 	}
 
@@ -773,13 +773,13 @@
 }
 
 void
-gaim_prefs_set_generic(const char *name, gpointer value)
+purple_prefs_set_generic(const char *name, gpointer value)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(!pref) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_set_generic: Unknown pref %s\n", name);
+		purple_debug_error("prefs",
+				"purple_prefs_set_generic: Unknown pref %s\n", name);
 		return;
 	}
 
@@ -788,14 +788,14 @@
 }
 
 void
-gaim_prefs_set_bool(const char *name, gboolean value)
+purple_prefs_set_bool(const char *name, gboolean value)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(pref) {
-		if(pref->type != GAIM_PREF_BOOLEAN) {
-			gaim_debug_error("prefs",
-					"gaim_prefs_set_bool: %s not a boolean pref\n", name);
+		if(pref->type != PURPLE_PREF_BOOLEAN) {
+			purple_debug_error("prefs",
+					"purple_prefs_set_bool: %s not a boolean pref\n", name);
 			return;
 		}
 
@@ -804,19 +804,19 @@
 			do_callbacks(name, pref);
 		}
 	} else {
-		gaim_prefs_add_bool(name, value);
+		purple_prefs_add_bool(name, value);
 	}
 }
 
 void
-gaim_prefs_set_int(const char *name, int value)
+purple_prefs_set_int(const char *name, int value)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(pref) {
-		if(pref->type != GAIM_PREF_INT) {
-			gaim_debug_error("prefs",
-					"gaim_prefs_set_int: %s not an integer pref\n", name);
+		if(pref->type != PURPLE_PREF_INT) {
+			purple_debug_error("prefs",
+					"purple_prefs_set_int: %s not an integer pref\n", name);
 			return;
 		}
 
@@ -825,24 +825,24 @@
 			do_callbacks(name, pref);
 		}
 	} else {
-		gaim_prefs_add_int(name, value);
+		purple_prefs_add_int(name, value);
 	}
 }
 
 void
-gaim_prefs_set_string(const char *name, const char *value)
+purple_prefs_set_string(const char *name, const char *value)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(value != NULL && !g_utf8_validate(value, -1, NULL)) {
-		gaim_debug_error("prefs", "gaim_prefs_set_string: Cannot store invalid UTF8 for string pref %s\n", name);
+		purple_debug_error("prefs", "purple_prefs_set_string: Cannot store invalid UTF8 for string pref %s\n", name);
 		return;
 	}
 
 	if(pref) {
-		if(pref->type != GAIM_PREF_STRING && pref->type != GAIM_PREF_PATH) {
-			gaim_debug_error("prefs",
-					"gaim_prefs_set_string: %s not a string pref\n", name);
+		if(pref->type != PURPLE_PREF_STRING && pref->type != PURPLE_PREF_PATH) {
+			purple_debug_error("prefs",
+					"purple_prefs_set_string: %s not a string pref\n", name);
 			return;
 		}
 
@@ -855,20 +855,20 @@
 			do_callbacks(name, pref);
 		}
 	} else {
-		gaim_prefs_add_string(name, value);
+		purple_prefs_add_string(name, value);
 	}
 }
 
 void
-gaim_prefs_set_string_list(const char *name, GList *value)
+purple_prefs_set_string_list(const char *name, GList *value)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 	if(pref) {
 		GList *tmp;
 
-		if(pref->type != GAIM_PREF_STRING_LIST) {
-			gaim_debug_error("prefs",
-					"gaim_prefs_set_string_list: %s not a string list pref\n",
+		if(pref->type != PURPLE_PREF_STRING_LIST) {
+			purple_debug_error("prefs",
+					"purple_prefs_set_string_list: %s not a string list pref\n",
 					name);
 			return;
 		}
@@ -879,7 +879,7 @@
 
 		for(tmp = value; tmp; tmp = tmp->next) {
 			if(tmp->data != NULL && !g_utf8_validate(tmp->data, -1, NULL)) {
-				gaim_debug_error("prefs", "gaim_prefs_set_string_list: Skipping invalid UTF8 for string list pref %s\n", name);
+				purple_debug_error("prefs", "purple_prefs_set_string_list: Skipping invalid UTF8 for string list pref %s\n", name);
 				continue;
 			}
 			pref->value.stringlist = g_list_prepend(pref->value.stringlist,
@@ -890,19 +890,19 @@
 		do_callbacks(name, pref);
 
 	} else {
-		gaim_prefs_add_string_list(name, value);
+		purple_prefs_add_string_list(name, value);
 	}
 }
 
 void
-gaim_prefs_set_path(const char *name, const char *value)
+purple_prefs_set_path(const char *name, const char *value)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(pref) {
-		if(pref->type != GAIM_PREF_PATH) {
-			gaim_debug_error("prefs",
-					"gaim_prefs_set_path: %s not a string pref\n", name);
+		if(pref->type != PURPLE_PREF_PATH) {
+			purple_debug_error("prefs",
+					"purple_prefs_set_path: %s not a string pref\n", name);
 			return;
 		}
 
@@ -915,20 +915,20 @@
 			do_callbacks(name, pref);
 		}
 	} else {
-		gaim_prefs_add_path(name, value);
+		purple_prefs_add_path(name, value);
 	}
 }
 
 void
-gaim_prefs_set_path_list(const char *name, GList *value)
+purple_prefs_set_path_list(const char *name, GList *value)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 	if(pref) {
 		GList *tmp;
 
-		if(pref->type != GAIM_PREF_PATH_LIST) {
-			gaim_debug_error("prefs",
-					"gaim_prefs_set_path_list: %s not a string list pref\n",
+		if(pref->type != PURPLE_PREF_PATH_LIST) {
+			purple_debug_error("prefs",
+					"purple_prefs_set_path_list: %s not a string list pref\n",
 					name);
 			return;
 		}
@@ -945,15 +945,15 @@
 		do_callbacks(name, pref);
 
 	} else {
-		gaim_prefs_add_path_list(name, value);
+		purple_prefs_add_path_list(name, value);
 	}
 }
 
 
 gboolean
-gaim_prefs_exists(const char *name)
+purple_prefs_exists(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if (pref != NULL)
 		return TRUE;
@@ -961,29 +961,29 @@
 	return FALSE;
 }
 
-GaimPrefType
-gaim_prefs_get_type(const char *name)
+PurplePrefType
+purple_prefs_get_type(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if (pref == NULL)
-		return GAIM_PREF_NONE;
+		return PURPLE_PREF_NONE;
 
 	return (pref->type);
 }
 
 gboolean
-gaim_prefs_get_bool(const char *name)
+purple_prefs_get_bool(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(!pref) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_bool: Unknown pref %s\n", name);
+		purple_debug_error("prefs",
+				"purple_prefs_get_bool: Unknown pref %s\n", name);
 		return FALSE;
-	} else if(pref->type != GAIM_PREF_BOOLEAN) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_bool: %s not a boolean pref\n", name);
+	} else if(pref->type != PURPLE_PREF_BOOLEAN) {
+		purple_debug_error("prefs",
+				"purple_prefs_get_bool: %s not a boolean pref\n", name);
 		return FALSE;
 	}
 
@@ -991,17 +991,17 @@
 }
 
 int
-gaim_prefs_get_int(const char *name)
+purple_prefs_get_int(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(!pref) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_int: Unknown pref %s\n", name);
+		purple_debug_error("prefs",
+				"purple_prefs_get_int: Unknown pref %s\n", name);
 		return 0;
-	} else if(pref->type != GAIM_PREF_INT) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_int: %s not an integer pref\n", name);
+	} else if(pref->type != PURPLE_PREF_INT) {
+		purple_debug_error("prefs",
+				"purple_prefs_get_int: %s not an integer pref\n", name);
 		return 0;
 	}
 
@@ -1009,17 +1009,17 @@
 }
 
 const char *
-gaim_prefs_get_string(const char *name)
+purple_prefs_get_string(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(!pref) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_string: Unknown pref %s\n", name);
+		purple_debug_error("prefs",
+				"purple_prefs_get_string: Unknown pref %s\n", name);
 		return NULL;
-	} else if(pref->type != GAIM_PREF_STRING) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_string: %s not a string pref\n", name);
+	} else if(pref->type != PURPLE_PREF_STRING) {
+		purple_debug_error("prefs",
+				"purple_prefs_get_string: %s not a string pref\n", name);
 		return NULL;
 	}
 
@@ -1027,18 +1027,18 @@
 }
 
 GList *
-gaim_prefs_get_string_list(const char *name)
+purple_prefs_get_string_list(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 	GList *ret = NULL, *tmp;
 
 	if(!pref) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_string_list: Unknown pref %s\n", name);
+		purple_debug_error("prefs",
+				"purple_prefs_get_string_list: Unknown pref %s\n", name);
 		return NULL;
-	} else if(pref->type != GAIM_PREF_STRING_LIST) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_string_list: %s not a string list pref\n", name);
+	} else if(pref->type != PURPLE_PREF_STRING_LIST) {
+		purple_debug_error("prefs",
+				"purple_prefs_get_string_list: %s not a string list pref\n", name);
 		return NULL;
 	}
 
@@ -1050,17 +1050,17 @@
 }
 
 const char *
-gaim_prefs_get_path(const char *name)
+purple_prefs_get_path(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 
 	if(!pref) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_path: Unknown pref %s\n", name);
+		purple_debug_error("prefs",
+				"purple_prefs_get_path: Unknown pref %s\n", name);
 		return NULL;
-	} else if(pref->type != GAIM_PREF_PATH) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_path: %s not a path pref\n", name);
+	} else if(pref->type != PURPLE_PREF_PATH) {
+		purple_debug_error("prefs",
+				"purple_prefs_get_path: %s not a path pref\n", name);
 		return NULL;
 	}
 
@@ -1068,18 +1068,18 @@
 }
 
 GList *
-gaim_prefs_get_path_list(const char *name)
+purple_prefs_get_path_list(const char *name)
 {
-	struct gaim_pref *pref = find_pref(name);
+	struct purple_pref *pref = find_pref(name);
 	GList *ret = NULL, *tmp;
 
 	if(!pref) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_path_list: Unknown pref %s\n", name);
+		purple_debug_error("prefs",
+				"purple_prefs_get_path_list: Unknown pref %s\n", name);
 		return NULL;
-	} else if(pref->type != GAIM_PREF_PATH_LIST) {
-		gaim_debug_error("prefs",
-				"gaim_prefs_get_path_list: %s not a path list pref\n", name);
+	} else if(pref->type != PURPLE_PREF_PATH_LIST) {
+		purple_debug_error("prefs",
+				"purple_prefs_get_path_list: %s not a path list pref\n", name);
 		return NULL;
 	}
 
@@ -1091,9 +1091,9 @@
 }
 
 void
-gaim_prefs_rename(const char *oldname, const char *newname)
+purple_prefs_rename(const char *oldname, const char *newname)
 {
-	struct gaim_pref *oldpref, *newpref;
+	struct purple_pref *oldpref, *newpref;
 
 	oldpref = find_pref(oldname);
 
@@ -1103,7 +1103,7 @@
 
 	if (oldpref->first_child != NULL) /* can't rename parents */
 	{
-		gaim_debug_error("prefs", "Unable to rename %s to %s: can't rename parents\n", oldname, newname);
+		purple_debug_error("prefs", "Unable to rename %s to %s: can't rename parents\n", oldname, newname);
 		return;
 	}
 
@@ -1112,38 +1112,38 @@
 
 	if (newpref == NULL)
 	{
-		gaim_debug_error("prefs", "Unable to rename %s to %s: new pref not created\n", oldname, newname);
+		purple_debug_error("prefs", "Unable to rename %s to %s: new pref not created\n", oldname, newname);
 		return;
 	}
 
 	if (oldpref->type != newpref->type)
 	{
-		gaim_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname);
+		purple_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname);
 		return;
 	}
 
-	gaim_debug_info("prefs", "Renaming %s to %s\n", oldname, newname);
+	purple_debug_info("prefs", "Renaming %s to %s\n", oldname, newname);
 
 	switch(oldpref->type) {
-		case GAIM_PREF_NONE:
+		case PURPLE_PREF_NONE:
 			break;
-		case GAIM_PREF_BOOLEAN:
-			gaim_prefs_set_bool(newname, oldpref->value.boolean);
+		case PURPLE_PREF_BOOLEAN:
+			purple_prefs_set_bool(newname, oldpref->value.boolean);
 			break;
-		case GAIM_PREF_INT:
-			gaim_prefs_set_int(newname, oldpref->value.integer);
+		case PURPLE_PREF_INT:
+			purple_prefs_set_int(newname, oldpref->value.integer);
 			break;
-		case GAIM_PREF_STRING:
-			gaim_prefs_set_string(newname, oldpref->value.string);
+		case PURPLE_PREF_STRING:
+			purple_prefs_set_string(newname, oldpref->value.string);
 			break;
-		case GAIM_PREF_STRING_LIST:
-			gaim_prefs_set_string_list(newname, oldpref->value.stringlist);
+		case PURPLE_PREF_STRING_LIST:
+			purple_prefs_set_string_list(newname, oldpref->value.stringlist);
 			break;
-		case GAIM_PREF_PATH:
-			gaim_prefs_set_path(newname, oldpref->value.string);
+		case PURPLE_PREF_PATH:
+			purple_prefs_set_path(newname, oldpref->value.string);
 			break;
-		case GAIM_PREF_PATH_LIST:
-			gaim_prefs_set_path_list(newname, oldpref->value.stringlist);
+		case PURPLE_PREF_PATH_LIST:
+			purple_prefs_set_path_list(newname, oldpref->value.stringlist);
 			break;
 	}
 
@@ -1151,9 +1151,9 @@
 }
 
 void
-gaim_prefs_rename_boolean_toggle(const char *oldname, const char *newname)
+purple_prefs_rename_boolean_toggle(const char *oldname, const char *newname)
 {
-		struct gaim_pref *oldpref, *newpref;
+		struct purple_pref *oldpref, *newpref;
 
 		oldpref = find_pref(oldname);
 
@@ -1161,15 +1161,15 @@
 		if(!oldpref)
 			return;
 
-		if (oldpref->type != GAIM_PREF_BOOLEAN)
+		if (oldpref->type != PURPLE_PREF_BOOLEAN)
 		{
-			gaim_debug_error("prefs", "Unable to rename %s to %s: old pref not a boolean\n", oldname, newname);
+			purple_debug_error("prefs", "Unable to rename %s to %s: old pref not a boolean\n", oldname, newname);
 			return;
 		}
 
 		if (oldpref->first_child != NULL) /* can't rename parents */
 		{
-			gaim_debug_error("prefs", "Unable to rename %s to %s: can't rename parents\n", oldname, newname);
+			purple_debug_error("prefs", "Unable to rename %s to %s: can't rename parents\n", oldname, newname);
 			return;
 		}
 
@@ -1178,26 +1178,26 @@
 
 		if (newpref == NULL)
 		{
-			gaim_debug_error("prefs", "Unable to rename %s to %s: new pref not created\n", oldname, newname);
+			purple_debug_error("prefs", "Unable to rename %s to %s: new pref not created\n", oldname, newname);
 			return;
 		}
 
 		if (oldpref->type != newpref->type)
 		{
-			gaim_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname);
+			purple_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname);
 			return;
 		}
 
-		gaim_debug_info("prefs", "Renaming and toggling %s to %s\n", oldname, newname);
-		gaim_prefs_set_bool(newname, !(oldpref->value.boolean));
+		purple_debug_info("prefs", "Renaming and toggling %s to %s\n", oldname, newname);
+		purple_prefs_set_bool(newname, !(oldpref->value.boolean));
 
 		remove_pref(oldpref);
 }
 
 guint
-gaim_prefs_connect_callback(void *handle, const char *name, GaimPrefCallback func, gpointer data)
+purple_prefs_connect_callback(void *handle, const char *name, PurplePrefCallback func, gpointer data)
 {
-	struct gaim_pref *pref;
+	struct purple_pref *pref;
 	struct pref_cb *cb;
 	static guint cb_id = 0;
 
@@ -1206,7 +1206,7 @@
 
 	pref = find_pref(name);
 	if (pref == NULL) {
-		gaim_debug_error("prefs", "gaim_prefs_connect_callback: Unknown pref %s\n", name);
+		purple_debug_error("prefs", "purple_prefs_connect_callback: Unknown pref %s\n", name);
 		return 0;
 	}
 
@@ -1223,10 +1223,10 @@
 }
 
 static gboolean
-disco_callback_helper(struct gaim_pref *pref, guint callback_id)
+disco_callback_helper(struct purple_pref *pref, guint callback_id)
 {
 	GSList *cbs;
-	struct gaim_pref *child;
+	struct purple_pref *child;
 
 	if(!pref)
 		return FALSE;
@@ -1249,16 +1249,16 @@
 }
 
 void
-gaim_prefs_disconnect_callback(guint callback_id)
+purple_prefs_disconnect_callback(guint callback_id)
 {
 	disco_callback_helper(&prefs, callback_id);
 }
 
 static void
-disco_callback_helper_handle(struct gaim_pref *pref, void *handle)
+disco_callback_helper_handle(struct purple_pref *pref, void *handle)
 {
 	GSList *cbs;
-	struct gaim_pref *child;
+	struct purple_pref *child;
 
 	if(!pref)
 		return;
@@ -1279,7 +1279,7 @@
 }
 
 void
-gaim_prefs_disconnect_by_handle(void *handle)
+purple_prefs_disconnect_by_handle(void *handle)
 {
 	g_return_if_fail(handle != NULL);
 
@@ -1287,45 +1287,45 @@
 }
 
 void
-gaim_prefs_update_old()
+purple_prefs_update_old()
 {
 	/* Remove some no-longer-used prefs */
-	gaim_prefs_remove("/core/away/auto_response/enabled");
-	gaim_prefs_remove("/core/away/auto_response/idle_only");
-	gaim_prefs_remove("/core/away/auto_response/in_active_conv");
-	gaim_prefs_remove("/core/away/auto_response/sec_before_resend");
-	gaim_prefs_remove("/core/away/auto_response");
-	gaim_prefs_remove("/core/away/default_message");
-	gaim_prefs_remove("/core/buddies/use_server_alias");
-	gaim_prefs_remove("/core/conversations/away_back_on_send");
-	gaim_prefs_remove("/core/conversations/send_urls_as_links");
-	gaim_prefs_remove("/core/conversations/im/show_login");
-	gaim_prefs_remove("/core/conversations/chat/show_join");
-	gaim_prefs_remove("/core/conversations/chat/show_leave");
-	gaim_prefs_remove("/core/conversations/combine_chat_im");
-	gaim_prefs_remove("/core/conversations/use_alias_for_title");
-	gaim_prefs_remove("/core/logging/log_signon_signoff");
-	gaim_prefs_remove("/core/logging/log_idle_state");
-	gaim_prefs_remove("/core/logging/log_away_state");
-	gaim_prefs_remove("/core/logging/log_own_states");
-	gaim_prefs_remove("/core/status/scores/hidden");
-	gaim_prefs_remove("/plugins/core/autorecon/hide_connected_error");
-	gaim_prefs_remove("/plugins/core/autorecon/hide_connecting_error");
-	gaim_prefs_remove("/plugins/core/autorecon/hide_reconnecting_dialog");
-	gaim_prefs_remove("/plugins/core/autorecon/restore_state");
-	gaim_prefs_remove("/plugins/core/autorecon");
+	purple_prefs_remove("/core/away/auto_response/enabled");
+	purple_prefs_remove("/core/away/auto_response/idle_only");
+	purple_prefs_remove("/core/away/auto_response/in_active_conv");
+	purple_prefs_remove("/core/away/auto_response/sec_before_resend");
+	purple_prefs_remove("/core/away/auto_response");
+	purple_prefs_remove("/core/away/default_message");
+	purple_prefs_remove("/core/buddies/use_server_alias");
+	purple_prefs_remove("/core/conversations/away_back_on_send");
+	purple_prefs_remove("/core/conversations/send_urls_as_links");
+	purple_prefs_remove("/core/conversations/im/show_login");
+	purple_prefs_remove("/core/conversations/chat/show_join");
+	purple_prefs_remove("/core/conversations/chat/show_leave");
+	purple_prefs_remove("/core/conversations/combine_chat_im");
+	purple_prefs_remove("/core/conversations/use_alias_for_title");
+	purple_prefs_remove("/core/logging/log_signon_signoff");
+	purple_prefs_remove("/core/logging/log_idle_state");
+	purple_prefs_remove("/core/logging/log_away_state");
+	purple_prefs_remove("/core/logging/log_own_states");
+	purple_prefs_remove("/core/status/scores/hidden");
+	purple_prefs_remove("/plugins/core/autorecon/hide_connected_error");
+	purple_prefs_remove("/plugins/core/autorecon/hide_connecting_error");
+	purple_prefs_remove("/plugins/core/autorecon/hide_reconnecting_dialog");
+	purple_prefs_remove("/plugins/core/autorecon/restore_state");
+	purple_prefs_remove("/plugins/core/autorecon");
 
 	/* Convert old sounds while_away pref to new 3-way pref. */
-	if (gaim_prefs_exists("/core/sound/while_away") &&
-	    gaim_prefs_get_bool("/core/sound/while_away"))
+	if (purple_prefs_exists("/core/sound/while_away") &&
+	    purple_prefs_get_bool("/core/sound/while_away"))
 	{
-		gaim_prefs_set_int("/core/sound/while_status", 3);
+		purple_prefs_set_int("/core/sound/while_status", 3);
 	}
-	gaim_prefs_remove("/core/sound/while_away");
+	purple_prefs_remove("/core/sound/while_away");
 }
 
 void *
-gaim_prefs_get_handle(void)
+purple_prefs_get_handle(void)
 {
 	static int handle;
 
@@ -1333,71 +1333,71 @@
 }
 
 void
-gaim_prefs_init(void)
+purple_prefs_init(void)
 {
-	void *handle = gaim_prefs_get_handle();
+	void *handle = purple_prefs_get_handle();
 
 	prefs_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 
-	gaim_prefs_connect_callback(handle, "/", prefs_save_cb, NULL);
+	purple_prefs_connect_callback(handle, "/", prefs_save_cb, NULL);
 
-	gaim_prefs_add_none("/core");
-	gaim_prefs_add_none("/plugins");
-	gaim_prefs_add_none("/plugins/core");
-	gaim_prefs_add_none("/plugins/lopl");
-	gaim_prefs_add_none("/plugins/prpl");
+	purple_prefs_add_none("/core");
+	purple_prefs_add_none("/plugins");
+	purple_prefs_add_none("/plugins/core");
+	purple_prefs_add_none("/plugins/lopl");
+	purple_prefs_add_none("/plugins/prpl");
 
 	/* Away */
-	gaim_prefs_add_none("/core/away");
-	gaim_prefs_add_string("/core/away/idle_reporting", "system");
-	gaim_prefs_add_bool("/core/away/away_when_idle", TRUE);
-	gaim_prefs_add_int("/core/away/mins_before_away", 5);
+	purple_prefs_add_none("/core/away");
+	purple_prefs_add_string("/core/away/idle_reporting", "system");
+	purple_prefs_add_bool("/core/away/away_when_idle", TRUE);
+	purple_prefs_add_int("/core/away/mins_before_away", 5);
 
 	/* Away -> Auto-Reply */
-	if (!gaim_prefs_exists("/core/away/auto_response/enabled") ||
-	    !gaim_prefs_exists("/core/away/auto_response/idle_only"))
+	if (!purple_prefs_exists("/core/away/auto_response/enabled") ||
+	    !purple_prefs_exists("/core/away/auto_response/idle_only"))
 	{
-		gaim_prefs_add_string("/core/away/auto_reply", "awayidle");
+		purple_prefs_add_string("/core/away/auto_reply", "awayidle");
 	}
 	else
 	{
-		if (!gaim_prefs_get_bool("/core/away/auto_response/enabled"))
+		if (!purple_prefs_get_bool("/core/away/auto_response/enabled"))
 		{
-			gaim_prefs_add_string("/core/away/auto_reply", "never");
+			purple_prefs_add_string("/core/away/auto_reply", "never");
 		}
 		else
 		{
-			if (gaim_prefs_get_bool("/core/away/auto_response/idle_only"))
+			if (purple_prefs_get_bool("/core/away/auto_response/idle_only"))
 			{
-				gaim_prefs_add_string("/core/away/auto_reply", "awayidle");
+				purple_prefs_add_string("/core/away/auto_reply", "awayidle");
 			}
 			else
 			{
-				gaim_prefs_add_string("/core/away/auto_reply", "away");
+				purple_prefs_add_string("/core/away/auto_reply", "away");
 			}
 		}
 	}
 
 	/* Buddies */
-	gaim_prefs_add_none("/core/buddies");
+	purple_prefs_add_none("/core/buddies");
 
 	/* Contact Priority Settings */
-	gaim_prefs_add_none("/core/contact");
-	gaim_prefs_add_bool("/core/contact/last_match", FALSE);
-	gaim_prefs_remove("/core/contact/offline_score");
-	gaim_prefs_remove("/core/contact/away_score");
-	gaim_prefs_remove("/core/contact/idle_score");
+	purple_prefs_add_none("/core/contact");
+	purple_prefs_add_bool("/core/contact/last_match", FALSE);
+	purple_prefs_remove("/core/contact/offline_score");
+	purple_prefs_remove("/core/contact/away_score");
+	purple_prefs_remove("/core/contact/idle_score");
 }
 
 void
-gaim_prefs_uninit()
+purple_prefs_uninit()
 {
 	if (save_timer != 0)
 	{
-		gaim_timeout_remove(save_timer);
+		purple_timeout_remove(save_timer);
 		save_timer = 0;
 		sync_prefs();
 	}
 
-	gaim_prefs_disconnect_by_handle(gaim_prefs_get_handle());
+	purple_prefs_disconnect_by_handle(purple_prefs_get_handle());
 }