Mercurial > pidgin3 / file comparison

comparison: libpurple/account.c

libpurple/account.c

branch
soc.2013.gobjectification
changeset 34580
ab3f70aaaf17
parent 34579
e718d0eea155
child 34581
b4e0236019e6
equal deleted inserted replaced
34579:e718d0eea155 34580:ab3f70aaaf17
89 void *registration_cb_user_data; 89 void *registration_cb_user_data;
90 90
91 PurpleConnectionErrorInfo *current_error; /**< Errors */ 91 PurpleConnectionErrorInfo *current_error; /**< Errors */
92 } PurpleAccountPrivate; 92 } PurpleAccountPrivate;
93 93
94 #if 0
95 /* TODO Use GValue instead */
96 typedef struct
97 {
98 PurplePrefType type;
99
100 char *ui;
101
102 union
103 {
104 int integer;
105 char *string;
106 gboolean boolean;
107
108 } value;
109
110 } PurpleAccountSetting;
111 #endif
112
113 typedef struct 94 typedef struct
114 { 95 {
115 PurpleAccountRequestType type; 96 PurpleAccountRequestType type;
116 PurpleAccount *account; 97 PurpleAccount *account;
117 void *ui_handle; 98 void *ui_handle;
126 { 107 {
127 PurpleCallback cb; 108 PurpleCallback cb;
128 gpointer data; 109 gpointer data;
129 } PurpleCallbackBundle; 110 } PurpleCallbackBundle;
130 111
112 static GObjectClass *parent_class = NULL;
113
114 /* GObject Property enums */
115 enum
116 {
117 PROP_0,
118 PROP_USERNAME,
119 PROP_PASSWORD,
120 PROP_PRIVATE_ALIAS,
121 PROP_PUBLIC_ALIAS,
122 PROP_ENABLED,
123 PROP_CONNECTION,
124 PROP_PROTOCOL_ID,
125 PROP_USER_INFO,
126 PROP_BUDDY_ICON_PATH,
127 PROP_REMEMBER_PASSWORD,
128 PROP_CHECK_MAIL,
129 PROP_LAST
130 };
131
132
131 static void set_current_error(PurpleAccount *account, 133 static void set_current_error(PurpleAccount *account,
132 PurpleConnectionErrorInfo *new_err); 134 PurpleConnectionErrorInfo *new_err);
133 135
134 136
135 PurpleAccount *
136 purple_account_new(const char *username, const char *protocol_id)
137 {
138 PurpleAccount *account = NULL;
139 PurplePlugin *prpl = NULL;
140 PurplePluginProtocolInfo *prpl_info = NULL;
141 PurpleStatusType *status_type;
142
143 g_return_val_if_fail(username != NULL, NULL);
144 g_return_val_if_fail(protocol_id != NULL, NULL);
145
146 account = purple_accounts_find(username, protocol_id);
147
148 if (account != NULL)
149 return account;
150
151 account = g_new0(PurpleAccount, 1);
152 PURPLE_DBUS_REGISTER_POINTER(account, PurpleAccount);
153
154 purple_account_set_username(account, username);
155
156 purple_account_set_protocol_id(account, protocol_id);
157
158 account->settings = g_hash_table_new_full(g_str_hash, g_str_equal,
159 g_free, delete_setting);
160 account->ui_settings = g_hash_table_new_full(g_str_hash, g_str_equal,
161 g_free, (GDestroyNotify)g_hash_table_destroy);
162 account->system_log = NULL;
163 /* 0 is not a valid privacy setting */
164 account->perm_deny = PURPLE_PRIVACY_ALLOW_ALL;
165
166 purple_signal_emit(purple_accounts_get_handle(), "account-created", account);
167
168 prpl = purple_find_prpl(protocol_id);
169
170 if (prpl == NULL)
171 return account;
172
173 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
174 if (prpl_info != NULL && prpl_info->status_types != NULL)
175 purple_account_set_status_types(account, prpl_info->status_types(account));
176
177 account->presence = purple_presence_new_for_account(account);
178
179 status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
180 if (status_type != NULL)
181 purple_presence_set_status_active(account->presence,
182 purple_status_type_get_id(status_type),
183 TRUE);
184 else
185 purple_presence_set_status_active(account->presence,
186 "offline",
187 TRUE);
188
189 return account;
190 }
191
192 void
193 purple_account_destroy(PurpleAccount *account)
194 {
195 GList *l;
196
197 g_return_if_fail(account != NULL);
198
199 purple_debug_info("account", "Destroying account %p\n", account);
200 purple_signal_emit(purple_accounts_get_handle(), "account-destroying", account);
201
202 for (l = purple_get_conversations(); l != NULL; l = l->next)
203 {
204 PurpleConversation *conv = (PurpleConversation *)l->data;
205
206 if (purple_conversation_get_account(conv) == account)
207 purple_conversation_set_account(conv, NULL);
208 }
209
210 g_free(account->username);
211 g_free(account->alias);
212 purple_str_wipe(account->password);
213 g_free(account->user_info);
214 g_free(account->buddy_icon_path);
215 g_free(account->protocol_id);
216
217 g_hash_table_destroy(account->settings);
218 g_hash_table_destroy(account->ui_settings);
219
220 if (account->proxy_info)
221 purple_proxy_info_destroy(account->proxy_info);
222
223 purple_account_set_status_types(account, NULL);
224
225 if (account->presence)
226 purple_presence_destroy(account->presence);
227
228 if(account->system_log)
229 purple_log_free(account->system_log);
230
231 while (account->deny) {
232 g_free(account->deny->data);
233 account->deny = g_slist_delete_link(account->deny, account->deny);
234 }
235
236 while (account->permit) {
237 g_free(account->permit->data);
238 account->permit = g_slist_delete_link(account->permit, account->permit);
239 }
240
241 PURPLE_DBUS_UNREGISTER_POINTER(account->current_error);
242 if (account->current_error) {
243 g_free(account->current_error->description);
244 g_free(account->current_error);
245 }
246
247 PURPLE_DBUS_UNREGISTER_POINTER(account);
248 g_free(account);
249 }
250
251 void 137 void
252 purple_account_set_register_callback(PurpleAccount *account, PurpleAccountRegistrationCb cb, void *user_data) 138 purple_account_set_register_callback(PurpleAccount *account, PurpleAccountRegistrationCb cb, void *user_data)
253 { 139 {
254 g_return_if_fail(account != NULL); 140 PurpleAccountPrivate *priv;
255 141
256 account->registration_cb = cb; 142 g_return_if_fail(account != NULL);
257 account->registration_cb_user_data = user_data; 143
144 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
145
146 priv->registration_cb = cb;
147 priv->registration_cb_user_data = user_data;
258 } 148 }
259 149
260 static void 150 static void
261 purple_account_register_got_password_cb(PurpleAccount *account, 151 purple_account_register_got_password_cb(PurpleAccount *account,
262 const gchar *password, GError *error, gpointer data) 152 const gchar *password, GError *error, gpointer data)
292 } 182 }
293 183
294 void 184 void
295 purple_account_register_completed(PurpleAccount *account, gboolean succeeded) 185 purple_account_register_completed(PurpleAccount *account, gboolean succeeded)
296 { 186 {
297 g_return_if_fail(account != NULL); 187 PurpleAccountPrivate *priv;
298 188
299 if (account->registration_cb) 189 g_return_if_fail(account != NULL);
300 (account->registration_cb)(account, succeeded, account->registration_cb_user_data); 190
191 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
192
193 if (priv->registration_cb)
194 (priv->registration_cb)(account, succeeded, priv->registration_cb_user_data);
301 } 195 }
302 196
303 void 197 void
304 purple_account_unregister(PurpleAccount *account, PurpleAccountUnregistrationCb cb, void *user_data) 198 purple_account_unregister(PurpleAccount *account, PurpleAccountUnregistrationCb cb, void *user_data)
305 { 199 {
408 purple_account_connect(PurpleAccount *account) 302 purple_account_connect(PurpleAccount *account)
409 { 303 {
410 PurplePlugin *prpl; 304 PurplePlugin *prpl;
411 const char *username; 305 const char *username;
412 PurplePluginProtocolInfo *prpl_info; 306 PurplePluginProtocolInfo *prpl_info;
307 PurpleAccountPrivate *priv;
413 308
414 g_return_if_fail(account != NULL); 309 g_return_if_fail(account != NULL);
415 310
416 username = purple_account_get_username(account); 311 username = purple_account_get_username(account);
417 312
430 purple_notify_error(account, _("Connection Error"), message, NULL); 325 purple_notify_error(account, _("Connection Error"), message, NULL);
431 g_free(message); 326 g_free(message);
432 return; 327 return;
433 } 328 }
434 329
330 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
331
435 purple_debug_info("account", "Connecting to account %s.\n", username); 332 purple_debug_info("account", "Connecting to account %s.\n", username);
436 333
437 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); 334 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
438 if (account->password != NULL) { 335 if (priv->password != NULL) {
439 purple_account_connect_got_password_cb(account, 336 purple_account_connect_got_password_cb(account,
440 account->password, NULL, prpl_info); 337 priv->password, NULL, prpl_info);
441 } else { 338 } else {
442 purple_keyring_get_password(account, 339 purple_keyring_get_password(account,
443 purple_account_connect_got_password_cb, prpl_info); 340 purple_account_connect_got_password_cb, prpl_info);
444 } 341 }
445 } 342 }
446 343
447 void 344 void
448 purple_account_disconnect(PurpleAccount *account) 345 purple_account_disconnect(PurpleAccount *account)
449 { 346 {
450 PurpleConnection *gc; 347 PurpleConnection *gc;
348 PurpleAccountPrivate *priv;
451 const char *username; 349 const char *username;
452 350
453 g_return_if_fail(account != NULL); 351 g_return_if_fail(account != NULL);
454 g_return_if_fail(!purple_account_is_disconnected(account)); 352 g_return_if_fail(!purple_account_is_disconnected(account));
353
354 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
455 355
456 username = purple_account_get_username(account); 356 username = purple_account_get_username(account);
457 purple_debug_info("account", "Disconnecting account %s (%p)\n", 357 purple_debug_info("account", "Disconnecting account %s (%p)\n",
458 username ? username : "(null)", account); 358 username ? username : "(null)", account);
459 359
460 account->disconnecting = TRUE; 360 priv->disconnecting = TRUE;
461 361
462 gc = purple_account_get_connection(account); 362 gc = purple_account_get_connection(account);
463 _purple_connection_destroy(gc); 363 _purple_connection_destroy(gc);
464 purple_account_set_connection(account, NULL); 364 purple_account_set_connection(account, NULL);
465 365
466 account->disconnecting = FALSE; 366 priv->disconnecting = FALSE;
467 } 367 }
468 368
469 gboolean 369 gboolean
470 purple_account_is_disconnecting(const PurpleAccount *account) 370 purple_account_is_disconnecting(const PurpleAccount *account)
471 { 371 {
372 PurpleAccountPrivate *priv;
373
472 g_return_val_if_fail(account != NULL, TRUE); 374 g_return_val_if_fail(account != NULL, TRUE);
473 375
474 return account->disconnecting; 376 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
377 return priv->disconnecting;
475 } 378 }
476 379
477 void 380 void
478 purple_account_notify_added(PurpleAccount *account, const char *remote_user, 381 purple_account_notify_added(PurpleAccount *account, const char *remote_user,
479 const char *id, const char *alias, 382 const char *id, const char *alias,
801 704
802 void 705 void
803 purple_account_set_username(PurpleAccount *account, const char *username) 706 purple_account_set_username(PurpleAccount *account, const char *username)
804 { 707 {
805 PurpleBlistUiOps *blist_ops; 708 PurpleBlistUiOps *blist_ops;
806 709 PurpleAccountPrivate *priv;
807 g_return_if_fail(account != NULL); 710
808 711 g_return_if_fail(account != NULL);
809 g_free(account->username); 712
810 account->username = g_strdup(username); 713 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
714
715 g_free(priv->username);
716 priv->username = g_strdup(username);
811 717
812 schedule_accounts_save(); 718 schedule_accounts_save();
813 719
814 /* if the name changes, we should re-write the buddy list 720 /* if the name changes, we should re-write the buddy list
815 * to disk with the new name */ 721 * to disk with the new name */
820 726
821 void 727 void
822 purple_account_set_password(PurpleAccount *account, const gchar *password, 728 purple_account_set_password(PurpleAccount *account, const gchar *password,
823 PurpleKeyringSaveCallback cb, gpointer data) 729 PurpleKeyringSaveCallback cb, gpointer data)
824 { 730 {
825 g_return_if_fail(account != NULL); 731 PurpleAccountPrivate *priv;
826 732
827 purple_str_wipe(account->password); 733 g_return_if_fail(account != NULL);
828 account->password = g_strdup(password); 734
735 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
736
737 purple_str_wipe(priv->password);
738 priv->password = g_strdup(password);
829 739
830 schedule_accounts_save(); 740 schedule_accounts_save();
831 741
832 if (!purple_account_get_remember_password(account)) { 742 if (!purple_account_get_remember_password(account)) {
833 purple_debug_info("account", 743 purple_debug_info("account",
842 } 752 }
843 753
844 void 754 void
845 purple_account_set_alias(PurpleAccount *account, const char *alias) 755 purple_account_set_alias(PurpleAccount *account, const char *alias)
846 { 756 {
847 g_return_if_fail(account != NULL); 757 PurpleAccountPrivate *priv;
758
759 g_return_if_fail(account != NULL);
760
761 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
848 762
849 /* 763 /*
850 * Do nothing if alias and account->alias are both NULL. Or if 764 * Do nothing if alias and priv->alias are both NULL. Or if
851 * they're the exact same string. 765 * they're the exact same string.
852 */ 766 */
853 if (alias == account->alias) 767 if (alias == priv->alias)
854 return; 768 return;
855 769
856 if ((!alias && account->alias) || (alias && !account->alias) || 770 if ((!alias && priv->alias) || (alias && !priv->alias) ||
857 g_utf8_collate(account->alias, alias)) 771 g_utf8_collate(priv->alias, alias))
858 { 772 {
859 char *old = account->alias; 773 char *old = priv->alias;
860 774
861 account->alias = g_strdup(alias); 775 priv->alias = g_strdup(alias);
862 purple_signal_emit(purple_accounts_get_handle(), "account-alias-changed", 776 purple_signal_emit(purple_accounts_get_handle(), "account-alias-changed",
863 account, old); 777 account, old);
864 g_free(old); 778 g_free(old);
865 779
866 schedule_accounts_save(); 780 schedule_accounts_save();
868 } 782 }
869 783
870 void 784 void
871 purple_account_set_user_info(PurpleAccount *account, const char *user_info) 785 purple_account_set_user_info(PurpleAccount *account, const char *user_info)
872 { 786 {
873 g_return_if_fail(account != NULL); 787 PurpleAccountPrivate *priv;
874 788
875 g_free(account->user_info); 789 g_return_if_fail(account != NULL);
876 account->user_info = g_strdup(user_info); 790
791 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
792
793 g_free(priv->user_info);
794 priv->user_info = g_strdup(user_info);
877 795
878 schedule_accounts_save(); 796 schedule_accounts_save();
879 } 797 }
880 798
881 void purple_account_set_buddy_icon_path(PurpleAccount *account, const char *path) 799 void purple_account_set_buddy_icon_path(PurpleAccount *account, const char *path)
882 { 800 {
883 g_return_if_fail(account != NULL); 801 PurpleAccountPrivate *priv;
884 802
885 g_free(account->buddy_icon_path); 803 g_return_if_fail(account != NULL);
886 account->buddy_icon_path = g_strdup(path); 804
805 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
806
807 g_free(priv->buddy_icon_path);
808 priv->buddy_icon_path = g_strdup(path);
887 809
888 schedule_accounts_save(); 810 schedule_accounts_save();
889 } 811 }
890 812
891 void 813 void
892 purple_account_set_protocol_id(PurpleAccount *account, const char *protocol_id) 814 purple_account_set_protocol_id(PurpleAccount *account, const char *protocol_id)
893 { 815 {
816 PurpleAccountPrivate *priv;
817
894 g_return_if_fail(account != NULL); 818 g_return_if_fail(account != NULL);
895 g_return_if_fail(protocol_id != NULL); 819 g_return_if_fail(protocol_id != NULL);
896 820
897 g_free(account->protocol_id); 821 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
898 account->protocol_id = g_strdup(protocol_id); 822
823 g_free(priv->protocol_id);
824 priv->protocol_id = g_strdup(protocol_id);
899 825
900 schedule_accounts_save(); 826 schedule_accounts_save();
901 } 827 }
902 828
903 void 829 void
904 purple_account_set_connection(PurpleAccount *account, PurpleConnection *gc) 830 purple_account_set_connection(PurpleAccount *account, PurpleConnection *gc)
905 { 831 {
906 g_return_if_fail(account != NULL); 832 PurpleAccountPrivate *priv;
907 833
908 account->gc = gc; 834 g_return_if_fail(account != NULL);
835
836 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
837 priv->gc = gc;
909 } 838 }
910 839
911 void 840 void
912 purple_account_set_remember_password(PurpleAccount *account, gboolean value) 841 purple_account_set_remember_password(PurpleAccount *account, gboolean value)
913 { 842 {
914 g_return_if_fail(account != NULL); 843 PurpleAccountPrivate *priv;
915 844
916 account->remember_pass = value; 845 g_return_if_fail(account != NULL);
846
847 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
848 priv->remember_pass = value;
917 849
918 schedule_accounts_save(); 850 schedule_accounts_save();
919 } 851 }
920 852
921 void 853 void
929 void 861 void
930 purple_account_set_enabled(PurpleAccount *account, const char *ui, 862 purple_account_set_enabled(PurpleAccount *account, const char *ui,
931 gboolean value) 863 gboolean value)
932 { 864 {
933 PurpleConnection *gc; 865 PurpleConnection *gc;
866 PurpleAccountPrivate *priv;
934 gboolean was_enabled = FALSE; 867 gboolean was_enabled = FALSE;
935 868
936 g_return_if_fail(account != NULL); 869 g_return_if_fail(account != NULL);
937 g_return_if_fail(ui != NULL); 870 g_return_if_fail(ui != NULL);
938 871
947 purple_signal_emit(purple_accounts_get_handle(), "account-enabled", account); 880 purple_signal_emit(purple_accounts_get_handle(), "account-enabled", account);
948 881
949 if ((gc != NULL) && (gc->wants_to_die == TRUE)) 882 if ((gc != NULL) && (gc->wants_to_die == TRUE))
950 return; 883 return;
951 884
952 if (value && purple_presence_is_online(account->presence)) 885 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
886
887 if (value && purple_presence_is_online(priv->presence))
953 purple_account_connect(account); 888 purple_account_connect(account);
954 else if (!value && !purple_account_is_disconnected(account)) 889 else if (!value && !purple_account_is_disconnected(account))
955 purple_account_disconnect(account); 890 purple_account_disconnect(account);
956 } 891 }
957 892
958 void 893 void
959 purple_account_set_proxy_info(PurpleAccount *account, PurpleProxyInfo *info) 894 purple_account_set_proxy_info(PurpleAccount *account, PurpleProxyInfo *info)
960 { 895 {
961 g_return_if_fail(account != NULL); 896 PurpleAccountPrivate *priv;
962 897
963 if (account->proxy_info != NULL) 898 g_return_if_fail(account != NULL);
964 purple_proxy_info_destroy(account->proxy_info); 899
965 900 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
966 account->proxy_info = info; 901
902 if (priv->proxy_info != NULL)
903 purple_proxy_info_destroy(priv->proxy_info);
904
905 priv->proxy_info = info;
967 906
968 schedule_accounts_save(); 907 schedule_accounts_save();
969 } 908 }
970 909
971 void 910 void
972 purple_account_set_privacy_type(PurpleAccount *account, PurpleAccountPrivacyType privacy_type) 911 purple_account_set_privacy_type(PurpleAccount *account, PurpleAccountPrivacyType privacy_type)
973 { 912 {
974 g_return_if_fail(account != NULL); 913 PurpleAccountPrivate *priv;
975 914
976 account->perm_deny = privacy_type; 915 g_return_if_fail(account != NULL);
916
917 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
918 priv->perm_deny = privacy_type;
977 } 919 }
978 920
979 void 921 void
980 purple_account_set_status_types(PurpleAccount *account, GList *status_types) 922 purple_account_set_status_types(PurpleAccount *account, GList *status_types)
981 { 923 {
982 g_return_if_fail(account != NULL); 924 PurpleAccountPrivate *priv;
925
926 g_return_if_fail(account != NULL);
927
928 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
983 929
984 /* Out with the old... */ 930 /* Out with the old... */
985 if (account->status_types != NULL) 931 if (priv->status_types != NULL)
986 { 932 {
987 g_list_foreach(account->status_types, (GFunc)purple_status_type_destroy, NULL); 933 g_list_foreach(priv->status_types, (GFunc)purple_status_type_destroy, NULL);
988 g_list_free(account->status_types); 934 g_list_free(priv->status_types);
989 } 935 }
990 936
991 /* In with the new... */ 937 /* In with the new... */
992 account->status_types = status_types; 938 priv->status_types = status_types;
993 } 939 }
994 940
995 void 941 void
996 purple_account_set_status(PurpleAccount *account, const char *status_id, 942 purple_account_set_status(PurpleAccount *account, const char *status_id,
997 gboolean active, ...) 943 gboolean active, ...)
1143 } 1089 }
1144 1090
1145 void 1091 void
1146 purple_account_clear_settings(PurpleAccount *account) 1092 purple_account_clear_settings(PurpleAccount *account)
1147 { 1093 {
1148 g_return_if_fail(account != NULL); 1094 PurpleAccountPrivate *priv;
1149 1095
1150 g_hash_table_destroy(account->settings); 1096 g_return_if_fail(account != NULL);
1151 1097
1152 account->settings = g_hash_table_new_full(g_str_hash, g_str_equal, 1098 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1099 g_hash_table_destroy(priv->settings);
1100
1101 priv->settings = g_hash_table_new_full(g_str_hash, g_str_equal,
1153 g_free, delete_setting); 1102 g_free, delete_setting);
1154 } 1103 }
1155 1104
1156 void 1105 void
1157 purple_account_remove_setting(PurpleAccount *account, const char *setting) 1106 purple_account_remove_setting(PurpleAccount *account, const char *setting)
1158 { 1107 {
1108 PurpleAccountPrivate *priv;
1109
1159 g_return_if_fail(account != NULL); 1110 g_return_if_fail(account != NULL);
1160 g_return_if_fail(setting != NULL); 1111 g_return_if_fail(setting != NULL);
1161 1112
1162 g_hash_table_remove(account->settings, setting); 1113 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1114
1115 g_hash_table_remove(priv->settings, setting);
1163 } 1116 }
1164 1117
1165 void 1118 void
1166 purple_account_set_int(PurpleAccount *account, const char *name, int value) 1119 purple_account_set_int(PurpleAccount *account, const char *name, int value)
1167 { 1120 {
1168 PurpleAccountSetting *setting; 1121 GValue *setting;
1122 PurpleAccountPrivate *priv;
1169 1123
1170 g_return_if_fail(account != NULL); 1124 g_return_if_fail(account != NULL);
1171 g_return_if_fail(name != NULL); 1125 g_return_if_fail(name != NULL);
1172 1126
1173 setting = g_new0(PurpleAccountSetting, 1); 1127 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1128
1129 setting = g_new0(GValue, 1);
1174 1130
1175 setting->type = PURPLE_PREF_INT; 1131 setting->type = PURPLE_PREF_INT;
1176 setting->value.integer = value; 1132 setting->value.integer = value;
1177 1133
1178 g_hash_table_insert(account->settings, g_strdup(name), setting); 1134 g_hash_table_insert(priv->settings, g_strdup(name), setting);
1179 1135
1180 schedule_accounts_save(); 1136 schedule_accounts_save();
1181 } 1137 }
1182 1138
1183 void 1139 void
1184 purple_account_set_string(PurpleAccount *account, const char *name, 1140 purple_account_set_string(PurpleAccount *account, const char *name,
1185 const char *value) 1141 const char *value)
1186 { 1142 {
1187 PurpleAccountSetting *setting; 1143 GValue *setting;
1144 PurpleAccountPrivate *priv;
1188 1145
1189 g_return_if_fail(account != NULL); 1146 g_return_if_fail(account != NULL);
1190 g_return_if_fail(name != NULL); 1147 g_return_if_fail(name != NULL);
1191 1148
1192 setting = g_new0(PurpleAccountSetting, 1); 1149 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1150
1151 setting = g_new0(GValue, 1);
1193 1152
1194 setting->type = PURPLE_PREF_STRING; 1153 setting->type = PURPLE_PREF_STRING;
1195 setting->value.string = g_strdup(value); 1154 setting->value.string = g_strdup(value);
1196 1155
1197 g_hash_table_insert(account->settings, g_strdup(name), setting); 1156 g_hash_table_insert(priv->settings, g_strdup(name), setting);
1198 1157
1199 schedule_accounts_save(); 1158 schedule_accounts_save();
1200 } 1159 }
1201 1160
1202 void 1161 void
1203 purple_account_set_bool(PurpleAccount *account, const char *name, gboolean value) 1162 purple_account_set_bool(PurpleAccount *account, const char *name, gboolean value)
1204 { 1163 {
1205 PurpleAccountSetting *setting; 1164 GValue *setting;
1165 PurpleAccountPrivate *priv;
1206 1166
1207 g_return_if_fail(account != NULL); 1167 g_return_if_fail(account != NULL);
1208 g_return_if_fail(name != NULL); 1168 g_return_if_fail(name != NULL);
1209 1169
1210 setting = g_new0(PurpleAccountSetting, 1); 1170 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1171
1172 setting = g_new0(GValue, 1);
1211 1173
1212 setting->type = PURPLE_PREF_BOOLEAN; 1174 setting->type = PURPLE_PREF_BOOLEAN;
1213 setting->value.boolean = value; 1175 setting->value.boolean = value;
1214 1176
1215 g_hash_table_insert(account->settings, g_strdup(name), setting); 1177 g_hash_table_insert(priv->settings, g_strdup(name), setting);
1216 1178
1217 schedule_accounts_save(); 1179 schedule_accounts_save();
1218 } 1180 }
1219 1181
1220 static GHashTable * 1182 static GHashTable *
1221 get_ui_settings_table(PurpleAccount *account, const char *ui) 1183 get_ui_settings_table(PurpleAccount *account, const char *ui)
1222 { 1184 {
1223 GHashTable *table; 1185 GHashTable *table;
1224 1186 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1225 table = g_hash_table_lookup(account->ui_settings, ui); 1187
1188 table = g_hash_table_lookup(priv->ui_settings, ui);
1226 1189
1227 if (table == NULL) { 1190 if (table == NULL) {
1228 table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, 1191 table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
1229 delete_setting); 1192 delete_setting);
1230 g_hash_table_insert(account->ui_settings, g_strdup(ui), table); 1193 g_hash_table_insert(priv->ui_settings, g_strdup(ui), table);
1231 } 1194 }
1232 1195
1233 return table; 1196 return table;
1234 } 1197 }
1235 1198
1236 void 1199 void
1237 purple_account_set_ui_int(PurpleAccount *account, const char *ui, 1200 purple_account_set_ui_int(PurpleAccount *account, const char *ui,
1238 const char *name, int value) 1201 const char *name, int value)
1239 { 1202 {
1240 PurpleAccountSetting *setting; 1203 GValue *setting;
1241 GHashTable *table; 1204 GHashTable *table;
1242 1205
1243 g_return_if_fail(account != NULL); 1206 g_return_if_fail(account != NULL);
1244 g_return_if_fail(ui != NULL); 1207 g_return_if_fail(ui != NULL);
1245 g_return_if_fail(name != NULL); 1208 g_return_if_fail(name != NULL);
1246 1209
1247 setting = g_new0(PurpleAccountSetting, 1); 1210 setting = g_new0(GValue, 1);
1248 1211
1249 setting->type = PURPLE_PREF_INT; 1212 setting->type = PURPLE_PREF_INT;
1250 setting->ui = g_strdup(ui); 1213 setting->ui = g_strdup(ui);
1251 setting->value.integer = value; 1214 setting->value.integer = value;
1252 1215
1259 1222
1260 void 1223 void
1261 purple_account_set_ui_string(PurpleAccount *account, const char *ui, 1224 purple_account_set_ui_string(PurpleAccount *account, const char *ui,
1262 const char *name, const char *value) 1225 const char *name, const char *value)
1263 { 1226 {
1264 PurpleAccountSetting *setting; 1227 GValue *setting;
1265 GHashTable *table; 1228 GHashTable *table;
1266 1229
1267 g_return_if_fail(account != NULL); 1230 g_return_if_fail(account != NULL);
1268 g_return_if_fail(ui != NULL); 1231 g_return_if_fail(ui != NULL);
1269 g_return_if_fail(name != NULL); 1232 g_return_if_fail(name != NULL);
1270 1233
1271 setting = g_new0(PurpleAccountSetting, 1); 1234 setting = g_new0(GValue, 1);
1272 1235
1273 setting->type = PURPLE_PREF_STRING; 1236 setting->type = PURPLE_PREF_STRING;
1274 setting->ui = g_strdup(ui); 1237 setting->ui = g_strdup(ui);
1275 setting->value.string = g_strdup(value); 1238 setting->value.string = g_strdup(value);
1276 1239
1283 1246
1284 void 1247 void
1285 purple_account_set_ui_bool(PurpleAccount *account, const char *ui, 1248 purple_account_set_ui_bool(PurpleAccount *account, const char *ui,
1286 const char *name, gboolean value) 1249 const char *name, gboolean value)
1287 { 1250 {
1288 PurpleAccountSetting *setting; 1251 GValue *setting;
1289 GHashTable *table; 1252 GHashTable *table;
1290 1253
1291 g_return_if_fail(account != NULL); 1254 g_return_if_fail(account != NULL);
1292 g_return_if_fail(ui != NULL); 1255 g_return_if_fail(ui != NULL);
1293 g_return_if_fail(name != NULL); 1256 g_return_if_fail(name != NULL);
1294 1257
1295 setting = g_new0(PurpleAccountSetting, 1); 1258 setting = g_new0(GValue, 1);
1296 1259
1297 setting->type = PURPLE_PREF_BOOLEAN; 1260 setting->type = PURPLE_PREF_BOOLEAN;
1298 setting->ui = g_strdup(ui); 1261 setting->ui = g_strdup(ui);
1299 setting->value.boolean = value; 1262 setting->value.boolean = value;
1300 1263
1338 } 1301 }
1339 1302
1340 const char * 1303 const char *
1341 purple_account_get_username(const PurpleAccount *account) 1304 purple_account_get_username(const PurpleAccount *account)
1342 { 1305 {
1306 PurpleAccountPrivate *priv;
1307
1343 g_return_val_if_fail(account != NULL, NULL); 1308 g_return_val_if_fail(account != NULL, NULL);
1344 1309
1345 return account->username; 1310 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1311 return priv->username;
1346 } 1312 }
1347 1313
1348 static void 1314 static void
1349 purple_account_get_password_got(PurpleAccount *account, 1315 purple_account_get_password_got(PurpleAccount *account,
1350 const gchar *password, GError *error, gpointer data) 1316 const gchar *password, GError *error, gpointer data)
1351 { 1317 {
1352 PurpleCallbackBundle *cbb = data; 1318 PurpleCallbackBundle *cbb = data;
1353 PurpleKeyringReadCallback cb; 1319 PurpleKeyringReadCallback cb;
1320 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1354 1321
1355 purple_debug_info("account", 1322 purple_debug_info("account",
1356 "Read password for account %s from async keyring.\n", 1323 "Read password for account %s from async keyring.\n",
1357 purple_account_get_username(account)); 1324 purple_account_get_username(account));
1358 1325
1359 purple_str_wipe(account->password); 1326 purple_str_wipe(priv->password);
1360 account->password = g_strdup(password); 1327 priv->password = g_strdup(password);
1361 1328
1362 cb = (PurpleKeyringReadCallback)cbb->cb; 1329 cb = (PurpleKeyringReadCallback)cbb->cb;
1363 if (cb != NULL) 1330 if (cb != NULL)
1364 cb(account, password, error, cbb->data); 1331 cb(account, password, error, cbb->data);
1365 1332
1368 1335
1369 void 1336 void
1370 purple_account_get_password(PurpleAccount *account, 1337 purple_account_get_password(PurpleAccount *account,
1371 PurpleKeyringReadCallback cb, gpointer data) 1338 PurpleKeyringReadCallback cb, gpointer data)
1372 { 1339 {
1340 PurpleAccountPrivate *priv;
1341
1373 if (account == NULL) { 1342 if (account == NULL) {
1374 cb(NULL, NULL, NULL, data); 1343 cb(NULL, NULL, NULL, data);
1375 return; 1344 return;
1376 } 1345 }
1377 1346
1378 if (account->password != NULL) { 1347 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1348
1349 if (priv->password != NULL) {
1379 purple_debug_info("account", 1350 purple_debug_info("account",
1380 "Reading password for account %s from cache.\n", 1351 "Reading password for account %s from cache.\n",
1381 purple_account_get_username(account)); 1352 purple_account_get_username(account));
1382 cb(account, account->password, NULL, data); 1353 cb(account, priv->password, NULL, data);
1383 } else { 1354 } else {
1384 PurpleCallbackBundle *cbb = g_new0(PurpleCallbackBundle, 1); 1355 PurpleCallbackBundle *cbb = g_new0(PurpleCallbackBundle, 1);
1385 cbb->cb = PURPLE_CALLBACK(cb); 1356 cbb->cb = PURPLE_CALLBACK(cb);
1386 cbb->data = data; 1357 cbb->data = data;
1387 1358
1394 } 1365 }
1395 1366
1396 const char * 1367 const char *
1397 purple_account_get_alias(const PurpleAccount *account) 1368 purple_account_get_alias(const PurpleAccount *account)
1398 { 1369 {
1370 PurpleAccountPrivate *priv;
1371
1399 g_return_val_if_fail(account != NULL, NULL); 1372 g_return_val_if_fail(account != NULL, NULL);
1400 1373
1401 return account->alias; 1374 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1375 return priv->alias;
1402 } 1376 }
1403 1377
1404 const char * 1378 const char *
1405 purple_account_get_user_info(const PurpleAccount *account) 1379 purple_account_get_user_info(const PurpleAccount *account)
1406 { 1380 {
1381 PurpleAccountPrivate *priv;
1382
1407 g_return_val_if_fail(account != NULL, NULL); 1383 g_return_val_if_fail(account != NULL, NULL);
1408 1384
1409 return account->user_info; 1385 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1386 return priv->user_info;
1410 } 1387 }
1411 1388
1412 const char * 1389 const char *
1413 purple_account_get_buddy_icon_path(const PurpleAccount *account) 1390 purple_account_get_buddy_icon_path(const PurpleAccount *account)
1414 { 1391 {
1392 PurpleAccountPrivate *priv;
1393
1415 g_return_val_if_fail(account != NULL, NULL); 1394 g_return_val_if_fail(account != NULL, NULL);
1416 1395
1417 return account->buddy_icon_path; 1396 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1397 return priv->buddy_icon_path;
1418 } 1398 }
1419 1399
1420 const char * 1400 const char *
1421 purple_account_get_protocol_id(const PurpleAccount *account) 1401 purple_account_get_protocol_id(const PurpleAccount *account)
1422 { 1402 {
1403 PurpleAccountPrivate *priv;
1404
1423 g_return_val_if_fail(account != NULL, NULL); 1405 g_return_val_if_fail(account != NULL, NULL);
1424 return account->protocol_id; 1406
1407 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1408 return priv->protocol_id;
1425 } 1409 }
1426 1410
1427 const char * 1411 const char *
1428 purple_account_get_protocol_name(const PurpleAccount *account) 1412 purple_account_get_protocol_name(const PurpleAccount *account)
1429 { 1413 {
1437 } 1421 }
1438 1422
1439 PurpleConnection * 1423 PurpleConnection *
1440 purple_account_get_connection(const PurpleAccount *account) 1424 purple_account_get_connection(const PurpleAccount *account)
1441 { 1425 {
1426 PurpleAccountPrivate *priv;
1427
1442 g_return_val_if_fail(account != NULL, NULL); 1428 g_return_val_if_fail(account != NULL, NULL);
1443 1429
1444 return account->gc; 1430 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1431 return priv->gc;
1445 } 1432 }
1446 1433
1447 const gchar * 1434 const gchar *
1448 purple_account_get_name_for_display(const PurpleAccount *account) 1435 purple_account_get_name_for_display(const PurpleAccount *account)
1449 { 1436 {
1481 } 1468 }
1482 1469
1483 gboolean 1470 gboolean
1484 purple_account_get_remember_password(const PurpleAccount *account) 1471 purple_account_get_remember_password(const PurpleAccount *account)
1485 { 1472 {
1473 PurpleAccountPrivate *priv;
1474
1486 g_return_val_if_fail(account != NULL, FALSE); 1475 g_return_val_if_fail(account != NULL, FALSE);
1487 1476
1488 return account->remember_pass; 1477 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1478 return priv->remember_pass;
1489 } 1479 }
1490 1480
1491 gboolean 1481 gboolean
1492 purple_account_get_check_mail(const PurpleAccount *account) 1482 purple_account_get_check_mail(const PurpleAccount *account)
1493 { 1483 {
1506 } 1496 }
1507 1497
1508 PurpleProxyInfo * 1498 PurpleProxyInfo *
1509 purple_account_get_proxy_info(const PurpleAccount *account) 1499 purple_account_get_proxy_info(const PurpleAccount *account)
1510 { 1500 {
1501 PurpleAccountPrivate *priv;
1502
1511 g_return_val_if_fail(account != NULL, NULL); 1503 g_return_val_if_fail(account != NULL, NULL);
1512 1504
1513 return account->proxy_info; 1505 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1506 return priv->proxy_info;
1514 } 1507 }
1515 1508
1516 PurpleAccountPrivacyType 1509 PurpleAccountPrivacyType
1517 purple_account_get_privacy_type(const PurpleAccount *account) 1510 purple_account_get_privacy_type(const PurpleAccount *account)
1518 { 1511 {
1512 PurpleAccountPrivate *priv;
1513
1519 g_return_val_if_fail(account != NULL, PURPLE_PRIVACY_ALLOW_ALL); 1514 g_return_val_if_fail(account != NULL, PURPLE_PRIVACY_ALLOW_ALL);
1520 1515
1521 return account->perm_deny; 1516 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1517 return priv->perm_deny;
1522 } 1518 }
1523 1519
1524 gboolean 1520 gboolean
1525 purple_account_privacy_permit_add(PurpleAccount *account, const char *who, 1521 purple_account_privacy_permit_add(PurpleAccount *account, const char *who,
1526 gboolean local_only) 1522 gboolean local_only)
1527 { 1523 {
1528 GSList *l; 1524 GSList *l;
1529 char *name; 1525 char *name;
1530 PurpleBuddy *buddy; 1526 PurpleBuddy *buddy;
1531 PurpleBlistUiOps *blist_ops; 1527 PurpleBlistUiOps *blist_ops;
1528 PurpleAccountPrivate *priv;
1532 1529
1533 g_return_val_if_fail(account != NULL, FALSE); 1530 g_return_val_if_fail(account != NULL, FALSE);
1534 g_return_val_if_fail(who != NULL, FALSE); 1531 g_return_val_if_fail(who != NULL, FALSE);
1535 1532
1533 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1536 name = g_strdup(purple_normalize(account, who)); 1534 name = g_strdup(purple_normalize(account, who));
1537 1535
1538 for (l = account->permit; l != NULL; l = l->next) { 1536 for (l = priv->permit; l != NULL; l = l->next) {
1539 if (g_str_equal(name, l->data)) 1537 if (g_str_equal(name, l->data))
1540 /* This buddy already exists */ 1538 /* This buddy already exists */
1541 break; 1539 break;
1542 } 1540 }
1543 1541
1546 /* This buddy already exists, so bail out */ 1544 /* This buddy already exists, so bail out */
1547 g_free(name); 1545 g_free(name);
1548 return FALSE; 1546 return FALSE;
1549 } 1547 }
1550 1548
1551 account->permit = g_slist_append(account->permit, name); 1549 priv->permit = g_slist_append(priv->permit, name);
1552 1550
1553 if (!local_only && purple_account_is_connected(account)) 1551 if (!local_only && purple_account_is_connected(account))
1554 serv_add_permit(purple_account_get_connection(account), who); 1552 serv_add_permit(purple_account_get_connection(account), who);
1555 1553
1556 if (privacy_ops != NULL && privacy_ops->permit_added != NULL) 1554 if (privacy_ops != NULL && privacy_ops->permit_added != NULL)
1576 GSList *l; 1574 GSList *l;
1577 const char *name; 1575 const char *name;
1578 PurpleBuddy *buddy; 1576 PurpleBuddy *buddy;
1579 char *del; 1577 char *del;
1580 PurpleBlistUiOps *blist_ops; 1578 PurpleBlistUiOps *blist_ops;
1579 PurpleAccountPrivate *priv;
1581 1580
1582 g_return_val_if_fail(account != NULL, FALSE); 1581 g_return_val_if_fail(account != NULL, FALSE);
1583 g_return_val_if_fail(who != NULL, FALSE); 1582 g_return_val_if_fail(who != NULL, FALSE);
1584 1583
1584 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1585 name = purple_normalize(account, who); 1585 name = purple_normalize(account, who);
1586 1586
1587 for (l = account->permit; l != NULL; l = l->next) { 1587 for (l = priv->permit; l != NULL; l = l->next) {
1588 if (g_str_equal(name, l->data)) 1588 if (g_str_equal(name, l->data))
1589 /* We found the buddy we were looking for */ 1589 /* We found the buddy we were looking for */
1590 break; 1590 break;
1591 } 1591 }
1592 1592
1596 1596
1597 /* We should not free l->data just yet. There can be occasions where 1597 /* We should not free l->data just yet. There can be occasions where
1598 * l->data == who. In such cases, freeing l->data here can cause crashes 1598 * l->data == who. In such cases, freeing l->data here can cause crashes
1599 * later when who is used. */ 1599 * later when who is used. */
1600 del = l->data; 1600 del = l->data;
1601 account->permit = g_slist_delete_link(account->permit, l); 1601 priv->permit = g_slist_delete_link(priv->permit, l);
1602 1602
1603 if (!local_only && purple_account_is_connected(account)) 1603 if (!local_only && purple_account_is_connected(account))
1604 serv_rem_permit(purple_account_get_connection(account), who); 1604 serv_rem_permit(purple_account_get_connection(account), who);
1605 1605
1606 if (privacy_ops != NULL && privacy_ops->permit_removed != NULL) 1606 if (privacy_ops != NULL && privacy_ops->permit_removed != NULL)
1625 { 1625 {
1626 GSList *l; 1626 GSList *l;
1627 char *name; 1627 char *name;
1628 PurpleBuddy *buddy; 1628 PurpleBuddy *buddy;
1629 PurpleBlistUiOps *blist_ops; 1629 PurpleBlistUiOps *blist_ops;
1630 PurpleAccountPrivate *priv;
1630 1631
1631 g_return_val_if_fail(account != NULL, FALSE); 1632 g_return_val_if_fail(account != NULL, FALSE);
1632 g_return_val_if_fail(who != NULL, FALSE); 1633 g_return_val_if_fail(who != NULL, FALSE);
1633 1634
1635 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1634 name = g_strdup(purple_normalize(account, who)); 1636 name = g_strdup(purple_normalize(account, who));
1635 1637
1636 for (l = account->deny; l != NULL; l = l->next) { 1638 for (l = priv->deny; l != NULL; l = l->next) {
1637 if (g_str_equal(name, l->data)) 1639 if (g_str_equal(name, l->data))
1638 /* This buddy already exists */ 1640 /* This buddy already exists */
1639 break; 1641 break;
1640 } 1642 }
1641 1643
1644 /* This buddy already exists, so bail out */ 1646 /* This buddy already exists, so bail out */
1645 g_free(name); 1647 g_free(name);
1646 return FALSE; 1648 return FALSE;
1647 } 1649 }
1648 1650
1649 account->deny = g_slist_append(account->deny, name); 1651 priv->deny = g_slist_append(priv->deny, name);
1650 1652
1651 if (!local_only && purple_account_is_connected(account)) 1653 if (!local_only && purple_account_is_connected(account))
1652 serv_add_deny(purple_account_get_connection(account), who); 1654 serv_add_deny(purple_account_get_connection(account), who);
1653 1655
1654 if (privacy_ops != NULL && privacy_ops->deny_added != NULL) 1656 if (privacy_ops != NULL && privacy_ops->deny_added != NULL)
1673 GSList *l; 1675 GSList *l;
1674 const char *normalized; 1676 const char *normalized;
1675 char *name; 1677 char *name;
1676 PurpleBuddy *buddy; 1678 PurpleBuddy *buddy;
1677 PurpleBlistUiOps *blist_ops; 1679 PurpleBlistUiOps *blist_ops;
1680 PurpleAccountPrivate *priv;
1678 1681
1679 g_return_val_if_fail(account != NULL, FALSE); 1682 g_return_val_if_fail(account != NULL, FALSE);
1680 g_return_val_if_fail(who != NULL, FALSE); 1683 g_return_val_if_fail(who != NULL, FALSE);
1681 1684
1685 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1682 normalized = purple_normalize(account, who); 1686 normalized = purple_normalize(account, who);
1683 1687
1684 for (l = account->deny; l != NULL; l = l->next) { 1688 for (l = priv->deny; l != NULL; l = l->next) {
1685 if (g_str_equal(normalized, l->data)) 1689 if (g_str_equal(normalized, l->data))
1686 /* We found the buddy we were looking for */ 1690 /* We found the buddy we were looking for */
1687 break; 1691 break;
1688 } 1692 }
1689 1693
1692 return FALSE; 1696 return FALSE;
1693 1697
1694 buddy = purple_find_buddy(account, normalized); 1698 buddy = purple_find_buddy(account, normalized);
1695 1699
1696 name = l->data; 1700 name = l->data;
1697 account->deny = g_slist_delete_link(account->deny, l); 1701 priv->deny = g_slist_delete_link(priv->deny, l);
1698 1702
1699 if (!local_only && purple_account_is_connected(account)) 1703 if (!local_only && purple_account_is_connected(account))
1700 serv_rem_deny(purple_account_get_connection(account), name); 1704 serv_rem_deny(purple_account_get_connection(account), name);
1701 1705
1702 if (privacy_ops != NULL && privacy_ops->deny_removed != NULL) 1706 if (privacy_ops != NULL && privacy_ops->deny_removed != NULL)
1722 */ 1726 */
1723 static void 1727 static void
1724 add_all_buddies_to_permit_list(PurpleAccount *account, gboolean local) 1728 add_all_buddies_to_permit_list(PurpleAccount *account, gboolean local)
1725 { 1729 {
1726 GSList *list; 1730 GSList *list;
1731 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1727 1732
1728 /* Remove anyone in the permit list who is not in the buddylist */ 1733 /* Remove anyone in the permit list who is not in the buddylist */
1729 for (list = account->permit; list != NULL; ) { 1734 for (list = priv->permit; list != NULL; ) {
1730 char *person = list->data; 1735 char *person = list->data;
1731 list = list->next; 1736 list = list->next;
1732 if (!purple_find_buddy(account, person)) 1737 if (!purple_find_buddy(account, person))
1733 purple_account_privacy_permit_remove(account, person, local); 1738 purple_account_privacy_permit_remove(account, person, local);
1734 } 1739 }
1738 while (list != NULL) 1743 while (list != NULL)
1739 { 1744 {
1740 PurpleBuddy *buddy = list->data; 1745 PurpleBuddy *buddy = list->data;
1741 const gchar *name = purple_buddy_get_name(buddy); 1746 const gchar *name = purple_buddy_get_name(buddy);
1742 1747
1743 if (!g_slist_find_custom(account->permit, name, (GCompareFunc)g_utf8_collate)) 1748 if (!g_slist_find_custom(priv->permit, name, (GCompareFunc)g_utf8_collate))
1744 purple_account_privacy_permit_add(account, name, local); 1749 purple_account_privacy_permit_add(account, name, local);
1745 list = g_slist_delete_link(list, list); 1750 list = g_slist_delete_link(list, list);
1746 } 1751 }
1747 } 1752 }
1748 1753
1749 void 1754 void
1750 purple_account_privacy_allow(PurpleAccount *account, const char *who) 1755 purple_account_privacy_allow(PurpleAccount *account, const char *who)
1751 { 1756 {
1752 GSList *list; 1757 GSList *list;
1753 PurpleAccountPrivacyType type = purple_account_get_privacy_type(account); 1758 PurpleAccountPrivacyType type = purple_account_get_privacy_type(account);
1759 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1754 1760
1755 switch (type) { 1761 switch (type) {
1756 case PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL: 1762 case PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL:
1757 return; 1763 return;
1758 case PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS: 1764 case PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS:
1762 purple_account_privacy_deny_remove(account, who, FALSE); 1768 purple_account_privacy_deny_remove(account, who, FALSE);
1763 break; 1769 break;
1764 case PURPLE_ACCOUNT_PRIVACY_DENY_ALL: 1770 case PURPLE_ACCOUNT_PRIVACY_DENY_ALL:
1765 /* Empty the allow-list. */ 1771 /* Empty the allow-list. */
1766 const char *norm = purple_normalize(account, who); 1772 const char *norm = purple_normalize(account, who);
1767 for (list = account->permit; list != NULL;) { 1773 for (list = priv->permit; list != NULL;) {
1768 char *person = list->data; 1774 char *person = list->data;
1769 list = list->next; 1775 list = list->next;
1770 if (!purple_strequal(norm, person)) 1776 if (!purple_strequal(norm, person))
1771 purple_account_privacy_permit_remove(account, person, FALSE); 1777 purple_account_privacy_permit_remove(account, person, FALSE);
1772 } 1778 }
1792 void 1798 void
1793 purple_account_privacy_deny(PurpleAccount *account, const char *who) 1799 purple_account_privacy_deny(PurpleAccount *account, const char *who)
1794 { 1800 {
1795 GSList *list; 1801 GSList *list;
1796 PurpleAccountPrivacyType type = purple_account_get_privacy_type(account); 1802 PurpleAccountPrivacyType type = purple_account_get_privacy_type(account);
1803 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1797 1804
1798 switch (type) { 1805 switch (type) {
1799 case PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL: 1806 case PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL:
1800 /* Empty the deny-list. */ 1807 /* Empty the deny-list. */
1801 const char *norm = purple_normalize(account, who); 1808 const char *norm = purple_normalize(account, who);
1802 for (list = account->deny; list != NULL; ) { 1809 for (list = priv->deny; list != NULL; ) {
1803 char *person = list->data; 1810 char *person = list->data;
1804 list = list->next; 1811 list = list->next;
1805 if (!purple_strequal(norm, person)) 1812 if (!purple_strequal(norm, person))
1806 purple_account_privacy_deny_remove(account, person, FALSE); 1813 purple_account_privacy_deny_remove(account, person, FALSE);
1807 } 1814 }
1836 purple_account_privacy_get_permitted(PurpleAccount *account) 1843 purple_account_privacy_get_permitted(PurpleAccount *account)
1837 { 1844 {
1838 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account); 1845 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1839 g_return_if_fail(priv != NULL); 1846 g_return_if_fail(priv != NULL);
1840 1847
1848 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1849
1841 return priv->permit; 1850 return priv->permit;
1842 } 1851 }
1843 1852
1844 GSList * 1853 GSList *
1845 purple_account_privacy_get_denied(PurpleAccount *account) 1854 purple_account_privacy_get_denied(PurpleAccount *account)
1846 { 1855 {
1847 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account); 1856 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1848 g_return_if_fail(priv != NULL); 1857 g_return_if_fail(priv != NULL);
1849 1858
1859 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1860
1850 return priv->deny; 1861 return priv->deny;
1851 } 1862 }
1852 1863
1853 gboolean 1864 gboolean
1854 purple_account_privacy_check(PurpleAccount *account, const char *who) 1865 purple_account_privacy_check(PurpleAccount *account, const char *who)
1855 { 1866 {
1856 GSList *list; 1867 GSList *list;
1868 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1857 1869
1858 switch (purple_account_get_privacy_type(account)) { 1870 switch (purple_account_get_privacy_type(account)) {
1859 case PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL: 1871 case PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL:
1860 return TRUE; 1872 return TRUE;
1861 1873
1862 case PURPLE_ACCOUNT_PRIVACY_DENY_ALL: 1874 case PURPLE_ACCOUNT_PRIVACY_DENY_ALL:
1863 return FALSE; 1875 return FALSE;
1864 1876
1865 case PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS: 1877 case PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS:
1866 who = purple_normalize(account, who); 1878 who = purple_normalize(account, who);
1867 for (list=account->permit; list!=NULL; list=list->next) { 1879 for (list=priv->permit; list!=NULL; list=list->next) {
1868 if (g_str_equal(who, list->data)) 1880 if (g_str_equal(who, list->data))
1869 return TRUE; 1881 return TRUE;
1870 } 1882 }
1871 return FALSE; 1883 return FALSE;
1872 1884
1873 case PURPLE_ACCOUNT_PRIVACY_DENY_USERS: 1885 case PURPLE_ACCOUNT_PRIVACY_DENY_USERS:
1874 who = purple_normalize(account, who); 1886 who = purple_normalize(account, who);
1875 for (list=account->deny; list!=NULL; list=list->next) { 1887 for (list=priv->deny; list!=NULL; list=list->next) {
1876 if (g_str_equal(who, list->data)) 1888 if (g_str_equal(who, list->data))
1877 return FALSE; 1889 return FALSE;
1878 } 1890 }
1879 return TRUE; 1891 return TRUE;
1880 1892
1887 } 1899 }
1888 1900
1889 PurpleStatus * 1901 PurpleStatus *
1890 purple_account_get_active_status(const PurpleAccount *account) 1902 purple_account_get_active_status(const PurpleAccount *account)
1891 { 1903 {
1904 PurpleAccountPrivate *priv;
1905
1892 g_return_val_if_fail(account != NULL, NULL); 1906 g_return_val_if_fail(account != NULL, NULL);
1893 1907
1894 return purple_presence_get_active_status(account->presence); 1908 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1909 return purple_presence_get_active_status(priv->presence);
1895 } 1910 }
1896 1911
1897 PurpleStatus * 1912 PurpleStatus *
1898 purple_account_get_status(const PurpleAccount *account, const char *status_id) 1913 purple_account_get_status(const PurpleAccount *account, const char *status_id)
1899 { 1914 {
1915 PurpleAccountPrivate *priv;
1916
1900 g_return_val_if_fail(account != NULL, NULL); 1917 g_return_val_if_fail(account != NULL, NULL);
1901 g_return_val_if_fail(status_id != NULL, NULL); 1918 g_return_val_if_fail(status_id != NULL, NULL);
1902 1919
1903 return purple_presence_get_status(account->presence, status_id); 1920 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1921
1922 return purple_presence_get_status(priv->presence, status_id);
1904 } 1923 }
1905 1924
1906 PurpleStatusType * 1925 PurpleStatusType *
1907 purple_account_get_status_type(const PurpleAccount *account, const char *id) 1926 purple_account_get_status_type(const PurpleAccount *account, const char *id)
1908 { 1927 {
1941 } 1960 }
1942 1961
1943 PurplePresence * 1962 PurplePresence *
1944 purple_account_get_presence(const PurpleAccount *account) 1963 purple_account_get_presence(const PurpleAccount *account)
1945 { 1964 {
1965 PurpleAccountPrivate *priv;
1966
1946 g_return_val_if_fail(account != NULL, NULL); 1967 g_return_val_if_fail(account != NULL, NULL);
1947 1968
1948 return account->presence; 1969 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1970 return priv->presence;
1949 } 1971 }
1950 1972
1951 gboolean 1973 gboolean
1952 purple_account_is_status_active(const PurpleAccount *account, 1974 purple_account_is_status_active(const PurpleAccount *account,
1953 const char *status_id) 1975 const char *status_id)
1954 { 1976 {
1977 PurpleAccountPrivate *priv;
1978
1955 g_return_val_if_fail(account != NULL, FALSE); 1979 g_return_val_if_fail(account != NULL, FALSE);
1956 g_return_val_if_fail(status_id != NULL, FALSE); 1980 g_return_val_if_fail(status_id != NULL, FALSE);
1957 1981
1958 return purple_presence_is_status_active(account->presence, status_id); 1982 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1983
1984 return purple_presence_is_status_active(priv->presence, status_id);
1959 } 1985 }
1960 1986
1961 GList * 1987 GList *
1962 purple_account_get_status_types(const PurpleAccount *account) 1988 purple_account_get_status_types(const PurpleAccount *account)
1963 { 1989 {
1990 PurpleAccountPrivate *priv;
1991
1964 g_return_val_if_fail(account != NULL, NULL); 1992 g_return_val_if_fail(account != NULL, NULL);
1965 1993
1966 return account->status_types; 1994 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1995 return priv->status_types;
1967 } 1996 }
1968 1997
1969 int 1998 int
1970 purple_account_get_int(const PurpleAccount *account, const char *name, 1999 purple_account_get_int(const PurpleAccount *account, const char *name,
1971 int default_value) 2000 int default_value)
1972 { 2001 {
1973 PurpleAccountSetting *setting; 2002 GValue *setting;
2003 PurpleAccountPrivate *priv;
1974 2004
1975 g_return_val_if_fail(account != NULL, default_value); 2005 g_return_val_if_fail(account != NULL, default_value);
1976 g_return_val_if_fail(name != NULL, default_value); 2006 g_return_val_if_fail(name != NULL, default_value);
1977 2007
1978 setting = g_hash_table_lookup(account->settings, name); 2008 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2009 setting = g_hash_table_lookup(priv->settings, name);
1979 2010
1980 if (setting == NULL) 2011 if (setting == NULL)
1981 return default_value; 2012 return default_value;
1982 2013
1983 g_return_val_if_fail(setting->type == PURPLE_PREF_INT, default_value); 2014 g_return_val_if_fail(setting->type == PURPLE_PREF_INT, default_value);
1987 2018
1988 const char * 2019 const char *
1989 purple_account_get_string(const PurpleAccount *account, const char *name, 2020 purple_account_get_string(const PurpleAccount *account, const char *name,
1990 const char *default_value) 2021 const char *default_value)
1991 { 2022 {
1992 PurpleAccountSetting *setting; 2023 GValue *setting;
2024 PurpleAccountPrivate *priv;
1993 2025
1994 g_return_val_if_fail(account != NULL, default_value); 2026 g_return_val_if_fail(account != NULL, default_value);
1995 g_return_val_if_fail(name != NULL, default_value); 2027 g_return_val_if_fail(name != NULL, default_value);
1996 2028
1997 setting = g_hash_table_lookup(account->settings, name); 2029 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2030 setting = g_hash_table_lookup(priv->settings, name);
1998 2031
1999 if (setting == NULL) 2032 if (setting == NULL)
2000 return default_value; 2033 return default_value;
2001 2034
2002 g_return_val_if_fail(setting->type == PURPLE_PREF_STRING, default_value); 2035 g_return_val_if_fail(setting->type == PURPLE_PREF_STRING, default_value);
2006 2039
2007 gboolean 2040 gboolean
2008 purple_account_get_bool(const PurpleAccount *account, const char *name, 2041 purple_account_get_bool(const PurpleAccount *account, const char *name,
2009 gboolean default_value) 2042 gboolean default_value)
2010 { 2043 {
2011 PurpleAccountSetting *setting; 2044 GValue *setting;
2045 PurpleAccountPrivate *priv;
2012 2046
2013 g_return_val_if_fail(account != NULL, default_value); 2047 g_return_val_if_fail(account != NULL, default_value);
2014 g_return_val_if_fail(name != NULL, default_value); 2048 g_return_val_if_fail(name != NULL, default_value);
2015 2049
2016 setting = g_hash_table_lookup(account->settings, name); 2050 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2051 setting = g_hash_table_lookup(priv->settings, name);
2017 2052
2018 if (setting == NULL) 2053 if (setting == NULL)
2019 return default_value; 2054 return default_value;
2020 2055
2021 g_return_val_if_fail(setting->type == PURPLE_PREF_BOOLEAN, default_value); 2056 g_return_val_if_fail(setting->type == PURPLE_PREF_BOOLEAN, default_value);
2025 2060
2026 int 2061 int
2027 purple_account_get_ui_int(const PurpleAccount *account, const char *ui, 2062 purple_account_get_ui_int(const PurpleAccount *account, const char *ui,
2028 const char *name, int default_value) 2063 const char *name, int default_value)
2029 { 2064 {
2030 PurpleAccountSetting *setting; 2065 GValue *setting;
2031 GHashTable *table; 2066 GHashTable *table;
2067 PurpleAccountPrivate *priv;
2032 2068
2033 g_return_val_if_fail(account != NULL, default_value); 2069 g_return_val_if_fail(account != NULL, default_value);
2034 g_return_val_if_fail(ui != NULL, default_value); 2070 g_return_val_if_fail(ui != NULL, default_value);
2035 g_return_val_if_fail(name != NULL, default_value); 2071 g_return_val_if_fail(name != NULL, default_value);
2036 2072
2037 if ((table = g_hash_table_lookup(account->ui_settings, ui)) == NULL) 2073 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2074
2075 if ((table = g_hash_table_lookup(priv->ui_settings, ui)) == NULL)
2038 return default_value; 2076 return default_value;
2039 2077
2040 if ((setting = g_hash_table_lookup(table, name)) == NULL) 2078 if ((setting = g_hash_table_lookup(table, name)) == NULL)
2041 return default_value; 2079 return default_value;
2042 2080
2047 2085
2048 const char * 2086 const char *
2049 purple_account_get_ui_string(const PurpleAccount *account, const char *ui, 2087 purple_account_get_ui_string(const PurpleAccount *account, const char *ui,
2050 const char *name, const char *default_value) 2088 const char *name, const char *default_value)
2051 { 2089 {
2052 PurpleAccountSetting *setting; 2090 GValue *setting;
2053 GHashTable *table; 2091 GHashTable *table;
2092 PurpleAccountPrivate *priv;
2054 2093
2055 g_return_val_if_fail(account != NULL, default_value); 2094 g_return_val_if_fail(account != NULL, default_value);
2056 g_return_val_if_fail(ui != NULL, default_value); 2095 g_return_val_if_fail(ui != NULL, default_value);
2057 g_return_val_if_fail(name != NULL, default_value); 2096 g_return_val_if_fail(name != NULL, default_value);
2058 2097
2059 if ((table = g_hash_table_lookup(account->ui_settings, ui)) == NULL) 2098 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2099
2100 if ((table = g_hash_table_lookup(priv->ui_settings, ui)) == NULL)
2060 return default_value; 2101 return default_value;
2061 2102
2062 if ((setting = g_hash_table_lookup(table, name)) == NULL) 2103 if ((setting = g_hash_table_lookup(table, name)) == NULL)
2063 return default_value; 2104 return default_value;
2064 2105
2069 2110
2070 gboolean 2111 gboolean
2071 purple_account_get_ui_bool(const PurpleAccount *account, const char *ui, 2112 purple_account_get_ui_bool(const PurpleAccount *account, const char *ui,
2072 const char *name, gboolean default_value) 2113 const char *name, gboolean default_value)
2073 { 2114 {
2074 PurpleAccountSetting *setting; 2115 GValue *setting;
2075 GHashTable *table; 2116 GHashTable *table;
2117 PurpleAccountPrivate *priv;
2076 2118
2077 g_return_val_if_fail(account != NULL, default_value); 2119 g_return_val_if_fail(account != NULL, default_value);
2078 g_return_val_if_fail(ui != NULL, default_value); 2120 g_return_val_if_fail(ui != NULL, default_value);
2079 g_return_val_if_fail(name != NULL, default_value); 2121 g_return_val_if_fail(name != NULL, default_value);
2080 2122
2081 if ((table = g_hash_table_lookup(account->ui_settings, ui)) == NULL) 2123 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2124
2125 if ((table = g_hash_table_lookup(priv->ui_settings, ui)) == NULL)
2082 return default_value; 2126 return default_value;
2083 2127
2084 if ((setting = g_hash_table_lookup(table, name)) == NULL) 2128 if ((setting = g_hash_table_lookup(table, name)) == NULL)
2085 return default_value; 2129 return default_value;
2086 2130
2090 } 2134 }
2091 2135
2092 gpointer 2136 gpointer
2093 purple_account_get_ui_data(const PurpleAccount *account) 2137 purple_account_get_ui_data(const PurpleAccount *account)
2094 { 2138 {
2095 g_return_val_if_fail(account != NULL, NULL); 2139 PurpleAccountPrivate *priv;
2096 2140
2097 return account->ui_data; 2141 g_return_val_if_fail(account != NULL, NULL);
2142
2143 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2144 return priv->ui_data;
2098 } 2145 }
2099 2146
2100 void 2147 void
2101 purple_account_set_ui_data(PurpleAccount *account, 2148 purple_account_set_ui_data(PurpleAccount *account,
2102 gpointer ui_data) 2149 gpointer ui_data)
2103 { 2150 {
2104 g_return_if_fail(account != NULL); 2151 PurpleAccountPrivate *priv;
2105 2152
2106 account->ui_data = ui_data; 2153 g_return_if_fail(account != NULL);
2154
2155 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2156 priv->ui_data = ui_data;
2107 } 2157 }
2108 2158
2109 2159
2110 PurpleLog * 2160 PurpleLog *
2111 purple_account_get_log(PurpleAccount *account, gboolean create) 2161 purple_account_get_log(PurpleAccount *account, gboolean create)
2112 { 2162 {
2163 PurpleAccountPrivate *priv;
2164
2113 g_return_val_if_fail(account != NULL, NULL); 2165 g_return_val_if_fail(account != NULL, NULL);
2114 2166
2115 if(!account->system_log && create){ 2167 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2168
2169 if(!priv->system_log && create){
2116 PurplePresence *presence; 2170 PurplePresence *presence;
2117 int login_time; 2171 int login_time;
2118 2172
2119 presence = purple_account_get_presence(account); 2173 presence = purple_account_get_presence(account);
2120 login_time = purple_presence_get_login_time(presence); 2174 login_time = purple_presence_get_login_time(presence);
2121 2175
2122 account->system_log = purple_log_new(PURPLE_LOG_SYSTEM, 2176 priv->system_log = purple_log_new(PURPLE_LOG_SYSTEM,
2123 purple_account_get_username(account), account, NULL, 2177 purple_account_get_username(account), account, NULL,
2124 (login_time != 0) ? login_time : time(NULL), NULL); 2178 (login_time != 0) ? login_time : time(NULL), NULL);
2125 } 2179 }
2126 2180
2127 return account->system_log; 2181 return priv->system_log;
2128 } 2182 }
2129 2183
2130 void 2184 void
2131 purple_account_destroy_log(PurpleAccount *account) 2185 purple_account_destroy_log(PurpleAccount *account)
2132 { 2186 {
2133 g_return_if_fail(account != NULL); 2187 PurpleAccountPrivate *priv;
2134 2188
2135 if(account->system_log){ 2189 g_return_if_fail(account != NULL);
2136 purple_log_free(account->system_log); 2190
2137 account->system_log = NULL; 2191 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2192
2193 if(priv->system_log){
2194 purple_log_free(priv->system_log);
2195 priv->system_log = NULL;
2138 } 2196 }
2139 } 2197 }
2140 2198
2141 void 2199 void
2142 purple_account_add_buddy(PurpleAccount *account, PurpleBuddy *buddy, const char *message) 2200 purple_account_add_buddy(PurpleAccount *account, PurpleBuddy *buddy, const char *message)
2328 2386
2329 static void 2387 static void
2330 set_current_error(PurpleAccount *account, PurpleConnectionErrorInfo *new_err) 2388 set_current_error(PurpleAccount *account, PurpleConnectionErrorInfo *new_err)
2331 { 2389 {
2332 PurpleConnectionErrorInfo *old_err; 2390 PurpleConnectionErrorInfo *old_err;
2333 2391 PurpleAccountPrivate *priv;
2334 g_return_if_fail(account != NULL); 2392
2335 2393 g_return_if_fail(account != NULL);
2336 old_err = account->current_error; 2394 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2395
2396 old_err = priv->current_error;
2337 2397
2338 if(new_err == old_err) 2398 if(new_err == old_err)
2339 return; 2399 return;
2340 2400
2341 account->current_error = new_err; 2401 priv->current_error = new_err;
2342 2402
2343 purple_signal_emit(purple_accounts_get_handle(), 2403 purple_signal_emit(purple_accounts_get_handle(),
2344 "account-error-changed", 2404 "account-error-changed",
2345 account, old_err, new_err); 2405 account, old_err, new_err);
2346 schedule_accounts_save(); 2406 schedule_accounts_save();
2386 } 2446 }
2387 2447
2388 const PurpleConnectionErrorInfo * 2448 const PurpleConnectionErrorInfo *
2389 purple_account_get_current_error(PurpleAccount *account) 2449 purple_account_get_current_error(PurpleAccount *account)
2390 { 2450 {
2391 return account->current_error; 2451 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2452
2453 return priv->current_error;
2392 } 2454 }
2393 2455
2394 void 2456 void
2395 purple_account_clear_current_error(PurpleAccount *account) 2457 purple_account_clear_current_error(PurpleAccount *account)
2396 { 2458 {
2397 set_current_error(account, NULL); 2459 set_current_error(account, NULL);
2460 }
2461
2462 /****************
2463 * GObject Code *
2464 ****************/
2465
2466 /* GObject Property names */
2467 #define PROP_USERNAME_S "username"
2468 #define PROP_PASSWORD_S "password"
2469 #define PROP_PRIVATE_ALIAS_S "private-alias"
2470 #define PROP_PUBLIC_ALIAS_S "public-alias"
2471 #define PROP_ENABLED_S "enabled"
2472 #define PROP_CONNECTION_S "connection"
2473 #define PROP_PROTOCOL_ID_S "protocol-id"
2474 #define PROP_USER_INFO_S "userinfo"
2475 #define PROP_BUDDY_ICON_PATH_S "buddy-icon-path"
2476 #define PROP_REMEMBER_PASSWORD_S "remember-password"
2477 #define PROP_CHECK_MAIL_S "check-mail"
2478
2479 /* Set method for GObject properties */
2480 static void
2481 purple_account_set_property(GObject *obj, guint param_id, const GValue *value,
2482 GParamSpec *pspec)
2483 {
2484 PurpleAccount *account = PURPLE_ACCOUNT(obj);
2485
2486 switch (param_id) {
2487 case PROP_USERNAME:
2488 purple_account_set_username(account, g_value_get_string(value));
2489 break;
2490 case PROP_PASSWORD:
2491 purple_account_set_password(account, g_value_get_string(value));
2492 break;
2493 case PROP_PRIVATE_ALIAS:
2494 purple_account_set_alias(account, g_value_get_string(value));
2495 break;
2496 case PROP_PUBLIC_ALIAS:
2497 purple_account_set_public_alias(account, g_value_get_string(value));
2498 break;
2499 case PROP_ENABLED:
2500 purple_account_set_enabled(account, g_value_get_boolean(value));
2501 break;
2502 case PROP_CONNECTION:
2503 purple_account_set_connection(account,
2504 PURPLE_CONNECTION(g_value_get_object(value)));
2505 break;
2506 case PROP_PROTOCOL_ID:
2507 purple_account_set_protocol_id(account, g_value_get_string(value));
2508 break;
2509 case PROP_USER_INFO:
2510 purple_account_set_user_info(account, g_value_get_string(value));
2511 break;
2512 case PROP_BUDDY_ICON_PATH:
2513 purple_account_set_buddy_icon_path(account,
2514 g_value_get_string(value));
2515 break;
2516 case PROP_REMEMBER_PASSWORD:
2517 purple_account_set_remember_password(account,
2518 g_value_get_boolean(value));
2519 break;
2520 case PROP_CHECK_MAIL:
2521 purple_account_set_check_mail(account, g_value_get_boolean(value));
2522 break;
2523 default:
2524 G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
2525 break;
2526 }
2527 }
2528
2529 /* Get method for GObject properties */
2530 static void
2531 purple_account_get_property(GObject *obj, guint param_id, GValue *value,
2532 GParamSpec *pspec)
2533 {
2534 PurpleAccount *account = PURPLE_ACCOUNT(obj);
2535
2536 switch (param_id) {
2537 case PROP_USERNAME:
2538 g_value_set_string(value, purple_account_get_username(account));
2539 break;
2540 case PROP_PASSWORD:
2541 g_value_set_string(value, purple_account_get_password(account));
2542 break;
2543 case PROP_PRIVATE_ALIAS:
2544 g_value_set_string(value, purple_account_get_alias(account));
2545 break;
2546 case PROP_PUBLIC_ALIAS:
2547 g_value_set_string(value, purple_account_get_public_alias(account));
2548 break;
2549 case PROP_ENABLED:
2550 g_value_set_boolean(value,
2551 purple_account_get_enabled(account));
2552 break;
2553 case PROP_CONNECTION:
2554 g_value_set_object(value,
2555 purple_account_get_connection(account));
2556 break;
2557 case PROP_PROTOCOL_ID:
2558 g_value_set_string(value, purple_account_get_protocol_id(account));
2559 break;
2560 case PROP_USER_INFO:
2561 g_value_set_string(value, purple_account_get_user_info(account));
2562 break;
2563 case PROP_BUDDY_ICON_PATH:
2564 g_value_set_string(value, purple_account_get_buddy_icon_path(account));
2565 break;
2566 case PROP_REMEMBER_PASSWORD:
2567 g_value_set_boolean(value, purple_account_get_remember_password(account));
2568 break;
2569 case PROP_CHECK_MAIL:
2570 g_value_set_boolean(value, purple_account_get_check_mail(account));
2571 break;
2572 default:
2573 G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
2574 break;
2575 }
2576 }
2577
2578 /* GObject initialization function */
2579 static void purple_account_init(GTypeInstance *instance, gpointer klass)
2580 {
2581 PurpleAccount *account = PURPLE_ACCOUNT(instance);
2582 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2583
2584 priv->settings = g_hash_table_new_full(g_str_hash, g_str_equal,
2585 g_free, delete_setting);
2586 priv->ui_settings = g_hash_table_new_full(g_str_hash, g_str_equal,
2587 g_free, (GDestroyNotify)g_hash_table_destroy);
2588 priv->system_log = NULL;
2589
2590 account->perm_deny = PURPLE_PRIVACY_ALLOW_ALL;
2591 }
2592
2593 /* GObject dispose function */
2594 static void
2595 purple_account_dispose(GObject *object)
2596 {
2597 GList *l;
2598 PurpleAccount *account = PURPLE_ACCOUNT(object);
2599 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2600
2601 purple_debug_info("account", "Destroying account %p\n", account);
2602 purple_signal_emit(purple_accounts_get_handle(), "account-destroying", account);
2603
2604 for (l = purple_get_conversations(); l != NULL; l = l->next)
2605 {
2606 PurpleConversation *conv = (PurpleConversation *)l->data;
2607
2608 if (purple_conversation_get_account(conv) == account)
2609 purple_conversation_set_account(conv, NULL);
2610 }
2611
2612 purple_account_set_status_types(account, NULL);
2613
2614 if (priv->proxy_info)
2615 purple_proxy_info_destroy(priv->proxy_info);
2616
2617 if (priv->presence)
2618 purple_presence_destroy(priv->presence);
2619
2620 if(priv->system_log)
2621 purple_log_free(priv->system_log);
2622
2623 if (priv->current_error) {
2624 g_free(priv->current_error->description);
2625 g_free(priv->current_error);
2626 }
2627
2628 PURPLE_DBUS_UNREGISTER_POINTER(priv->current_error);
2629 PURPLE_DBUS_UNREGISTER_POINTER(account);
2630
2631 parent_class->dispose(object);
2632 }
2633
2634 /* GObject finalize function */
2635 static void
2636 purple_account_finalize(GObject *object)
2637 {
2638 PurpleAccount *account = PURPLE_ACCOUNT(object);
2639 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2640
2641 g_free(priv->username);
2642 g_free(priv->alias);
2643 purple_str_wipe(priv->password);
2644 g_free(priv->user_info);
2645 g_free(priv->buddy_icon_path);
2646 g_free(priv->protocol_id);
2647
2648 g_hash_table_destroy(priv->settings);
2649 g_hash_table_destroy(priv->ui_settings);
2650
2651 while (priv->deny) {
2652 g_free(priv->deny->data);
2653 priv->deny = g_slist_delete_link(priv->deny, priv->deny);
2654 }
2655
2656 while (priv->permit) {
2657 g_free(priv->permit->data);
2658 priv->permit = g_slist_delete_link(priv->permit, priv->permit);
2659 }
2660
2661 parent_class->finalize(object);
2662 }
2663
2664 /* Class initializer function */
2665 static void purple_account_class_init(PurpleAccountClass *klass)
2666 {
2667 GObjectClass *obj_class = G_OBJECT_CLASS(klass);
2668
2669 parent_class = g_type_class_peek_parent(klass);
2670
2671 obj_class->dispose = purple_account_dispose;
2672 obj_class->finalize = purple_account_finalize;
2673
2674 /* Setup properties */
2675 obj_class->get_property = purple_account_get_property;
2676 obj_class->set_property = purple_account_set_property;
2677
2678 g_object_class_install_property(obj_class, PROP_USERNAME,
2679 g_param_spec_string(PROP_USERNAME_S, _("Username"),
2680 _("The username for the account."), NULL,
2681 G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
2682 );
2683
2684 g_object_class_install_property(obj_class, PROP_PASSWORD,
2685 g_param_spec_string(PROP_PASSWORD_S, _("Password"),
2686 _("The password for the account."), NULL,
2687 G_PARAM_READWRITE)
2688 );
2689
2690 g_object_class_install_property(obj_class, PROP_PRIVATE_ALIAS,
2691 g_param_spec_string(PROP_PRIVATE_ALIAS_S, _("Private Alias"),
2692 _("The private alias for the account."), NULL,
2693 G_PARAM_READWRITE)
2694 );
2695
2696 g_object_class_install_property(obj_class, PROP_PUBLIC_ALIAS,
2697 g_param_spec_string(PROP_PUBLIC_ALIAS_S, _("Public Alias"),
2698 _("The public alias for the account."), NULL,
2699 G_PARAM_READWRITE)
2700 );
2701
2702 g_object_class_install_property(obj_class, PROP_USER_INFO,
2703 g_param_spec_string(PROP_USER_INFO_S, _("User information"),
2704 _("Detailed user information for the account."), NULL,
2705 G_PARAM_READWRITE)
2706 );
2707
2708 g_object_class_install_property(obj_class, PROP_BUDDY_ICON_PATH,
2709 g_param_spec_string(PROP_BUDDY_ICON_PATH_S, _("Buddy icon path"),
2710 _("Path to the buddyicon for the account."), NULL,
2711 G_PARAM_READWRITE)
2712 );
2713
2714 g_object_class_install_property(obj_class, PROP_ENABLED,
2715 g_param_spec_boolean(PROP_ENABLED_S, _("Enabled"),
2716 _("Whether the account is enabled or not."), FALSE,
2717 G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
2718 );
2719
2720 g_object_class_install_property(obj_class, PROP_REMEMBER_PASSWORD,
2721 g_param_spec_boolean(PROP_REMEMBER_PASSWORD_S, _("Remember password"),
2722 _("Whether to remember and store the password for this account."), FALSE,
2723 G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
2724 );
2725
2726 g_object_class_install_property(obj_class, PROP_CHECK_MAIL,
2727 g_param_spec_boolean(PROP_CHECK_MAIL_S, _("Check mail"),
2728 _("Whether to check mails for this account."), FALSE,
2729 G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
2730 );
2731
2732 g_object_class_install_property(obj_class, PROP_CONNECTION,
2733 g_param_spec_object(PROP_CONNECTION_S, _("Connection"),
2734 _("The PurpleConnection object for the account."),
2735 PURPLE_TYPE_CONNECTION,
2736 G_PARAM_READWRITE)
2737 );
2738
2739 g_object_class_install_property(obj_class, PROP_PROTOCOL_ID,
2740 g_param_spec_string(PROP_PROTOCOL_ID_S, _("Protocol ID"),
2741 _("ID of the protocol that is responsible for the account."), NULL,
2742 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)
2743 );
2744
2745 g_type_class_add_private(klass, sizeof(PurpleAccountPrivate));
2398 } 2746 }
2399 2747
2400 GType 2748 GType
2401 purple_account_get_type(void) 2749 purple_account_get_type(void)
2402 { 2750 {
2405 if(type == 0) { 2753 if(type == 0) {
2406 static const GTypeInfo info = { 2754 static const GTypeInfo info = {
2407 sizeof(PurpleAccountClass), 2755 sizeof(PurpleAccountClass),
2408 NULL, 2756 NULL,
2409 NULL, 2757 NULL,
2410 NULL, /*TODO: (GClassInitFunc)purple_account_class_init,*/ 2758 (GClassInitFunc)purple_account_class_init,
2411 NULL, 2759 NULL,
2412 NULL, 2760 NULL,
2413 sizeof(PurpleAccount), 2761 sizeof(PurpleAccount),
2414 0, 2762 0,
2415 NULL, /*TODO: (GInstanceInitFunc)purple_account_init,*/ 2763 (GInstanceInitFunc)purple_account_init,
2416 NULL, 2764 NULL,
2417 }; 2765 };
2418 2766
2419 type = g_type_register_static(G_TYPE_OBJECT, 2767 type = g_type_register_static(G_TYPE_OBJECT,
2420 "PurpleAccount", 2768 "PurpleAccount",
2421 &info, 0); 2769 &info, 0);
2422 } 2770 }
2423 2771
2424 return type; 2772 return type;
2425 } 2773 }
2774
2775 PurpleAccount *
2776 purple_account_new(const char *username, const char *protocol_id)
2777 {
2778 PurpleAccount *account = NULL;
2779 PurplePlugin *prpl = NULL;
2780 PurplePluginProtocolInfo *prpl_info = NULL;
2781 PurpleStatusType *status_type;
2782 PurpleAccountPrivate *priv;
2783
2784 g_return_val_if_fail(username != NULL, NULL);
2785 g_return_val_if_fail(protocol_id != NULL, NULL);
2786
2787 account = purple_accounts_find(username, protocol_id);
2788
2789 if (account != NULL)
2790 return account;
2791
2792 account = g_object_new(PURPLE_TYPE_ACCOUNT,
2793 PROP_USERNAME_S, username,
2794 PROP_PROTOCOL_ID_S, protocol_id,
2795 NULL);
2796 PURPLE_DBUS_REGISTER_POINTER(account, PurpleAccount);
2797
2798 purple_signal_emit(purple_accounts_get_handle(), "account-created", account);
2799
2800 prpl = purple_find_prpl(protocol_id);
2801 if (prpl == NULL)
2802 return account;
2803
2804 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
2805 if (prpl_info != NULL && prpl_info->status_types != NULL)
2806 purple_account_set_status_types(account, prpl_info->status_types(account));
2807
2808 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2809
2810 priv->presence = purple_presence_new_for_account(account);
2811
2812 status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
2813 if (status_type != NULL)
2814 purple_presence_set_status_active(priv->presence,
2815 purple_status_type_get_id(status_type),
2816 TRUE);
2817 else
2818 purple_presence_set_status_active(priv->presence,
2819 "offline",
2820 TRUE);
2821
2822 return account;
2823 }

Mercurial Repository: pidgin3

mercurial