src/purple/purple-buddy.c

   1 /**
   2  * @file purple-buddy.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-11 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <glib.h>
  28
  29 #include "purple-private.h"
  30
  31 #include "blist.h"
  32 #include "notify.h"
  33 #include "privacy.h"
  34 #include "request.h"
  35 #include "version.h"
  36
  37 #include "sipe-common.h"
  38 #include "sipe-backend.h"
  39 #include "sipe-core.h"
  40 #include "sipe-nls.h"
  41
  42 static const struct {
  43         const gchar *property;    /* property name to store in blist.xml */
  44         const gchar *description; /* label for "Get Info" dialog */
  45 } buddy_info_map[] = {
  46 /* SIPE_BUDDY_INFO_DISPLAY_NAME          */ { "alias",                 N_("Display name")   },
  47 /* SIPE_BUDDY_INFO_JOB_TITLE             */ { "title",                 N_("Job title")      },
  48 /* SIPE_BUDDY_INFO_CITY                  */ { "address-city",          N_("City")           },
  49 /* SIPE_BUDDY_INFO_STATE                 */ { "address-state",         N_("State")          },
  50 /* SIPE_BUDDY_INFO_OFFICE                */ { "office",                N_("Office")         },
  51 /* SIPE_BUDDY_INFO_DEPARTMENT            */ { "department",            NULL                 },
  52 /* SIPE_BUDDY_INFO_COUNTRY               */ { "address-country-code",  N_("Country")        },
  53 /* SIPE_BUDDY_INFO_WORK_PHONE            */ { "phone",                 N_("Business phone") },
  54 /* SIPE_BUDDY_INFO_WORK_PHONE_DISPLAY    */ { "phone-display",         NULL                 },
  55 /* SIPE_BUDDY_INFO_COMPANY               */ { "company",               N_("Company")        },
  56 /* SIPE_BUDDY_INFO_EMAIL                 */ { "email",                 N_("Email address")  },
  57 /* SIPE_BUDDY_INFO_SITE                  */ { "site",                  N_("Site")           },
  58 /* SIPE_BUDDY_INFO_ZIPCODE               */ { "address-zipcode",       NULL                 },
  59 /* SIPE_BUDDY_INFO_STREET                */ { "address-street",        NULL                 },
  60 /* SIPE_BUDDY_INFO_MOBILE_PHONE          */ { "phone-mobile",          NULL                 },
  61 /* SIPE_BUDDY_INFO_MOBILE_PHONE_DISPLAY  */ { "phone-mobile-display",  NULL                 },
  62 /* SIPE_BUDDY_INFO_HOME_PHONE            */ { "phone-home",            NULL                 },
  63 /* SIPE_BUDDY_INFO_HOME_PHONE_DISPLAY    */ { "phone-home-display",    NULL                 },
  64 /* SIPE_BUDDY_INFO_OTHER_PHONE           */ { "phone-other",           NULL                 },
  65 /* SIPE_BUDDY_INFO_OTHER_PHONE_DISPLAY   */ { "phone-other-display",   NULL                 },
  66 /* SIPE_BUDDY_INFO_CUSTOM1_PHONE         */ { "phone-custom1",         NULL                 },
  67 /* SIPE_BUDDY_INFO_CUSTOM1_PHONE_DISPLAY */ { "phone-custom1-display", NULL                 },
  68 /* SIPE_BUDDY_INFO_ALIAS                 */ { NULL,                    N_("Alias")          },
  69 /* SIPE_BUDDY_INFO_DEVICE                */ { NULL,                    N_("Device")         },
  70 };
  71
  72 #define buddy_info_property(i)    buddy_info_map[i].property
  73 #define buddy_info_description(i) gettext(buddy_info_map[i].description)
  74
  75 sipe_backend_buddy sipe_backend_buddy_find(struct sipe_core_public *sipe_public,
  76                                            const gchar *buddy_name,
  77                                            const gchar *group_name)
  78 {
  79         struct sipe_backend_private *purple_private = sipe_public->backend_private;
  80         PurpleGroup *purple_group;
  81
  82         if (group_name)
  83         {
  84                 purple_group = purple_find_group(group_name);
  85                 if (!purple_group)
  86                         return NULL;
  87
  88                 return purple_find_buddy_in_group(purple_private->account,
  89                                                   buddy_name,
  90                                                   purple_group);
  91         } else {
  92                 return purple_find_buddy(purple_private->account,
  93                                          buddy_name);
  94         }
  95 }
  96
  97 GSList* sipe_backend_buddy_find_all(struct sipe_core_public *sipe_public,
  98                                     const gchar *buddy_name,
  99                                     const gchar *group_name)
 100 {
 101         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 102
 103         if (group_name)
 104         {
 105                 SIPE_DEBUG_ERROR_NOFORMAT("Finding all buddies in a group not supported on purple");
 106                 return NULL;
 107         }
 108
 109         return purple_find_buddies(purple_private->account, buddy_name);
 110 }
 111
 112 gchar* sipe_backend_buddy_get_name(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 113                                    const sipe_backend_buddy who)
 114 {
 115         return g_strdup(((PurpleBuddy*)who)->name);
 116 }
 117
 118 gchar* sipe_backend_buddy_get_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 119                                     const sipe_backend_buddy who)
 120 {
 121         return g_strdup(purple_buddy_get_alias(who));
 122 }
 123
 124 gchar* sipe_backend_buddy_get_server_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 125                                            const sipe_backend_buddy who)
 126 {
 127         return g_strdup(purple_buddy_get_server_alias(who));
 128 }
 129
 130 gchar *sipe_backend_buddy_get_local_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 131                                           const sipe_backend_buddy who)
 132 {
 133         return g_strdup(purple_buddy_get_local_alias(who));
 134 }
 135
 136 gchar* sipe_backend_buddy_get_group_name(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 137                                          const sipe_backend_buddy who)
 138 {
 139         return g_strdup(purple_buddy_get_group((PurpleBuddy*)who)->name);
 140 }
 141
 142 guint sipe_backend_buddy_get_status(struct sipe_core_public *sipe_public,
 143                                     const gchar *uri)
 144 {
 145         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 146         PurpleBuddy *pbuddy = purple_find_buddy(purple_private->account, uri);
 147         const PurplePresence *presence = purple_buddy_get_presence(pbuddy);
 148         const PurpleStatus *pstatus = purple_presence_get_active_status(presence);
 149         return(sipe_purple_token_to_activity(purple_status_get_id(pstatus)));
 150 }
 151
 152 void sipe_backend_buddy_set_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 153                                   const sipe_backend_buddy who,
 154                                   const gchar *alias)
 155 {
 156         purple_blist_alias_buddy(who, alias);
 157 }
 158
 159 void sipe_backend_buddy_set_server_alias(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 160                                          const sipe_backend_buddy who,
 161                                          const gchar *alias)
 162 {
 163         purple_blist_server_alias_buddy(who, alias);
 164 }
 165
 166 gchar* sipe_backend_buddy_get_string(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 167                                      sipe_backend_buddy buddy,
 168                                      const sipe_buddy_info_fields key)
 169 {
 170         PurpleBuddy *b = (PurpleBuddy*) buddy;
 171         return g_strdup(purple_blist_node_get_string(&b->node, buddy_info_property(key)));
 172 }
 173
 174 void sipe_backend_buddy_set_string(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 175                                    sipe_backend_buddy buddy,
 176                                    const sipe_buddy_info_fields key,
 177                                    const gchar *val)
 178 {
 179         PurpleBuddy *b = (PurpleBuddy*) buddy;
 180         purple_blist_node_set_string(&b->node, buddy_info_property(key), val);
 181 }
 182
 183 sipe_backend_buddy sipe_backend_buddy_add(struct sipe_core_public *sipe_public,
 184                                           const gchar *name,
 185                                           const gchar *alias,
 186                                           const gchar *groupname)
 187 {
 188         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 189         PurpleBuddy *b;
 190         PurpleGroup *purple_group = purple_find_group(groupname);
 191
 192         if (!purple_group)
 193                 return NULL;
 194
 195         b = purple_buddy_new(purple_private->account, name, alias);
 196         purple_blist_add_buddy(b, NULL, purple_group, NULL);
 197         return b;
 198 }
 199
 200 void sipe_backend_buddy_remove(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 201                                const sipe_backend_buddy who)
 202 {
 203         purple_blist_remove_buddy(who);
 204 }
 205
 206 void sipe_backend_buddy_request_authorization(struct sipe_core_public *sipe_public,
 207                                               const gchar *who,
 208                                               const gchar *alias,
 209                                               gboolean on_list,
 210                                               sipe_backend_buddy_request_authorization_cb auth_cb,
 211                                               sipe_backend_buddy_request_authorization_cb deny_cb,
 212                                               gpointer data)
 213 {
 214         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 215
 216         purple_account_request_authorization(
 217                 purple_private->account,
 218                 who,
 219                 _("you"), /* id */
 220                 alias,
 221                 NULL, /* message */
 222                 on_list,
 223                 auth_cb,
 224                 deny_cb,
 225                 data);
 226
 227 }
 228
 229 void sipe_backend_buddy_request_add(struct sipe_core_public *sipe_public,
 230                                     const gchar *who,
 231                                     const gchar *alias)
 232 {
 233         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 234
 235         purple_account_request_add(purple_private->account,
 236                                    who,
 237                                    _("you"),
 238                                    alias,
 239                                    NULL);
 240
 241 }
 242
 243 gboolean sipe_backend_buddy_is_blocked(struct sipe_core_public *sipe_public,
 244                                        const gchar *who)
 245 {
 246         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 247
 248         return !purple_privacy_check(purple_private->account, who);
 249 }
 250
 251 void sipe_backend_buddy_set_blocked_status(struct sipe_core_public *sipe_public,
 252                                       const gchar *who,
 253                                       gboolean blocked)
 254 {
 255         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 256
 257         if (blocked) {
 258                 purple_privacy_deny_add(purple_private->account, who, TRUE);
 259         } else {
 260                 purple_privacy_deny_remove(purple_private->account, who, TRUE);
 261         }
 262
 263         /* stupid workaround to make pidgin re-render screen to reflect our changes */
 264         SIPE_DEBUG_INFO_NOFORMAT("sipe_backend_buddy_set_blocked_status: forcefully refreshing screen.");
 265         sipe_core_buddy_got_status(sipe_public,
 266                                    who,
 267                                    sipe_backend_buddy_get_status(sipe_public,
 268                                                                  who));
 269 }
 270
 271 void sipe_backend_buddy_set_status(struct sipe_core_public *sipe_public,
 272                                    const gchar *who,
 273                                    guint activity)
 274 {
 275         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 276
 277         purple_prpl_got_user_status(purple_private->account, who,
 278                                     sipe_purple_activity_to_token(activity),
 279                                     NULL);
 280 }
 281
 282 gboolean sipe_backend_buddy_group_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 283                                       const gchar *group_name)
 284 {
 285         PurpleGroup * purple_group = purple_find_group(group_name);
 286         if (!purple_group) {
 287                 purple_group = purple_group_new(group_name);
 288                 purple_blist_add_group(purple_group, NULL);
 289         }
 290
 291         return (purple_group != NULL);
 292 }
 293
 294 struct sipe_backend_buddy_info *sipe_backend_buddy_info_start(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public)
 295 {
 296         return((struct sipe_backend_buddy_info *)purple_notify_user_info_new());
 297 }
 298
 299 void sipe_backend_buddy_info_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 300                                  struct sipe_backend_buddy_info *info,
 301                                  sipe_buddy_info_fields key,
 302                                  const gchar *value)
 303 {
 304         if (info) {
 305 #if PURPLE_VERSION_CHECK(3,0,0)
 306                 purple_notify_user_info_add_pair_html
 307 #else
 308                 purple_notify_user_info_add_pair
 309 #endif
 310                         ((PurpleNotifyUserInfo *) info,
 311                          buddy_info_description(key),
 312                          value);
 313         }
 314 }
 315
 316 void sipe_backend_buddy_info_break(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 317                                    struct sipe_backend_buddy_info *info)
 318 {
 319         purple_notify_user_info_add_section_break((PurpleNotifyUserInfo *) info);
 320 }
 321
 322 void sipe_backend_buddy_info_finalize(struct sipe_core_public *sipe_public,
 323                                       struct sipe_backend_buddy_info *info,
 324                                       const gchar *uri)
 325 {
 326         struct sipe_backend_private *purple_private = sipe_public->backend_private;
 327
 328         /* show a buddy's user info in a nice dialog box */
 329         purple_notify_userinfo(purple_private->gc,
 330                                uri,       /* buddy's URI */
 331                                (PurpleNotifyUserInfo *) info,
 332                                NULL,      /* callback called when dialog closed */
 333                                NULL);     /* userdata for callback */
 334 }
 335
 336 void sipe_backend_buddy_tooltip_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 337                                     struct sipe_backend_buddy_tooltip *tooltip,
 338                                     const gchar *description,
 339                                     const gchar *value)
 340 {
 341 #if PURPLE_VERSION_CHECK(3,0,0)
 342         purple_notify_user_info_add_pair_html
 343 #else
 344         purple_notify_user_info_add_pair
 345 #endif
 346                 ((PurpleNotifyUserInfo *) tooltip, description, value);
 347 }
 348
 349 void sipe_purple_add_buddy(PurpleConnection *gc,
 350                            PurpleBuddy *buddy,
 351                            PurpleGroup *group)
 352 {
 353         SIPE_DEBUG_INFO("sipe_purple_add_buddy[CB]: buddy:%s group:%s",
 354                         buddy ? buddy->name : "",
 355                         group ? group->name : "");
 356
 357         /* libpurple can call us with undefined buddy or group */
 358         if (buddy && group) {
 359                 /*
 360                  * Buddy name must be lower case as we use
 361                  * purple_normalize_nocase() to compare
 362                  */
 363                 gchar *buddy_name = g_ascii_strdown(buddy->name, -1);
 364                 gchar *uri        = sip_uri(buddy_name);
 365                 g_free(buddy_name);
 366                 purple_blist_rename_buddy(buddy, uri);
 367                 g_free(uri);
 368
 369                 sipe_core_buddy_add(PURPLE_GC_TO_SIPE_CORE_PUBLIC,
 370                                     buddy->name,
 371                                     group->name);
 372         }
 373 }
 374
 375 void sipe_purple_remove_buddy(PurpleConnection *gc,
 376                               PurpleBuddy *buddy,
 377                               PurpleGroup *group)
 378 {
 379         SIPE_DEBUG_INFO("sipe_purple_remove_buddy[CB]: buddy:%s group:%s", buddy ? buddy->name : "", group ? group->name : "");
 380         if (!buddy) return;
 381
 382         sipe_core_buddy_remove(PURPLE_GC_TO_SIPE_CORE_PUBLIC,
 383                                buddy->name,
 384                                group ? group->name : NULL);
 385 }
 386
 387 void sipe_purple_group_buddy(PurpleConnection *gc,
 388                              const char *who,
 389                              const char *old_group_name,
 390                              const char *new_group_name)
 391 {
 392         sipe_core_buddy_group(PURPLE_GC_TO_SIPE_CORE_PUBLIC, who, old_group_name, new_group_name);
 393 }
 394
 395 /* Buddy Menu Handling */
 396
 397 static void sipe_purple_buddy_make_chat_leader_cb(PurpleBuddy *buddy,
 398                                                   gpointer parameter)
 399 {
 400         SIPE_DEBUG_INFO("sipe_purple_buddy_make_chat_leader_cb: buddy->name=%s",
 401                         buddy->name);
 402         sipe_core_conf_make_leader(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 403                                    parameter,
 404                                    buddy->name);
 405 }
 406
 407 static void sipe_purple_buddy_remove_from_chat_cb(PurpleBuddy *buddy,
 408                                                   gpointer parameter)
 409 {
 410         SIPE_DEBUG_INFO("sipe_purple_buddy_remove_from_chat_cb: buddy->name=%s",
 411                         buddy->name);
 412         sipe_core_conf_remove_from(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 413                                    parameter,
 414                                    buddy->name);
 415 }
 416
 417 static void sipe_purple_buddy_invite_to_chat_cb(PurpleBuddy *buddy,
 418                                                 gpointer parameter)
 419 {
 420         SIPE_DEBUG_INFO("sipe_purple_buddy_invite_to_chat_cb: buddy->name=%s",
 421                         buddy->name);
 422         sipe_core_chat_invite(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 423                               parameter,
 424                               buddy->name);
 425 }
 426
 427 static void sipe_purple_buddy_new_chat_cb(PurpleBuddy *buddy,
 428                                           SIPE_UNUSED_PARAMETER gpointer parameter)
 429 {
 430         SIPE_DEBUG_INFO("sipe_purple_buddy_new_chat_cb: buddy->name=%s",
 431                         buddy->name);
 432         sipe_core_buddy_new_chat(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 433                                  buddy->name);
 434 }
 435
 436 static void sipe_purple_buddy_make_call_cb(PurpleBuddy *buddy,
 437                                            gpointer parameter)
 438 {
 439         SIPE_DEBUG_INFO("sipe_purple_buddy_make_call_cb: buddy->name=%s", buddy->name);
 440         sipe_core_buddy_make_call(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 441                                   parameter);
 442 }
 443
 444 static void sipe_purple_buddy_send_email_cb(PurpleBuddy *buddy,
 445                                             SIPE_UNUSED_PARAMETER gpointer parameter)
 446 {
 447         SIPE_DEBUG_INFO("sipe_purple_buddy_send_email_cb: buddy->name=%s",
 448                         buddy->name);
 449         sipe_core_buddy_send_email(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 450                                    buddy->name);
 451 }
 452
 453 static void sipe_purple_buddy_access_level_help_cb(PurpleBuddy *buddy,
 454                                                    SIPE_UNUSED_PARAMETER gpointer parameter)
 455 {
 456         /**
 457          * Translators: replace with URL to localized page
 458          * If it doesn't exist copy the original URL
 459          */
 460         purple_notify_uri(buddy->account->gc,
 461                           _("https://sourceforge.net/apps/mediawiki/sipe/index.php?title=Access_Levels"));
 462 }
 463
 464 static void sipe_purple_buddy_change_access_level_cb(PurpleBuddy *buddy,
 465                                                      gpointer parameter)
 466 {
 467         sipe_core_change_access_level_from_container(PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC,
 468                                                      parameter);
 469 }
 470
 471 static void sipe_purple_ask_access_domain_cb(PurpleConnection *gc,
 472                                              PurpleRequestFields *fields)
 473 {
 474         const gchar *domain = purple_request_fields_get_string(fields, "access_domain");
 475         guint index         = purple_request_fields_get_choice(fields, "container_id");
 476         sipe_core_change_access_level_for_domain(PURPLE_GC_TO_SIPE_CORE_PUBLIC,
 477                                                  domain,
 478                                                  index);
 479 }
 480
 481 static void sipe_purple_buddy_add_new_domain_cb(PurpleBuddy *buddy,
 482                                                 SIPE_UNUSED_PARAMETER gpointer parameter)
 483 {
 484         PurpleConnection *gc = purple_account_get_connection(buddy->account);
 485         PurpleRequestFields *fields;
 486         PurpleRequestFieldGroup *g;
 487         PurpleRequestField *f;
 488
 489         fields = purple_request_fields_new();
 490
 491         g = purple_request_field_group_new(NULL);
 492         f = purple_request_field_string_new("access_domain",
 493                                             _("Domain"),
 494                                             "partner-company.com",
 495                                             FALSE);
 496         purple_request_field_set_required(f, TRUE);
 497         purple_request_field_group_add_field(g, f);
 498
 499         f = purple_request_field_choice_new("container_id",
 500                                             _("Access level"),
 501                                             0);
 502         purple_request_field_choice_add(f, _("Personal")); /* index 0 */
 503         purple_request_field_choice_add(f, _("Team"));
 504         purple_request_field_choice_add(f, _("Company"));
 505         purple_request_field_choice_add(f, _("Public"));
 506         purple_request_field_choice_add(f, _("Blocked")); /* index 4 */
 507         purple_request_field_choice_set_default_value(f, 3); /* index */
 508         purple_request_field_set_required(f, TRUE);
 509         purple_request_field_group_add_field(g, f);
 510
 511         purple_request_fields_add_group(fields, g);
 512
 513         purple_request_fields(gc, _("Add new domain"),
 514                               _("Add new domain"), NULL, fields,
 515                               _("Add"), G_CALLBACK(sipe_purple_ask_access_domain_cb),
 516                               _("Cancel"), NULL,
 517                               buddy->account, NULL, NULL, gc);
 518 }
 519
 520 typedef void (*buddy_menu_callback)(PurpleBuddy *buddy,
 521                                     gpointer parameter);
 522 static const buddy_menu_callback callback_map[SIPE_BUDDY_MENU_TYPES] = {
 523 /* SIPE_BUDDY_MENU_MAKE_CHAT_LEADER    */ sipe_purple_buddy_make_chat_leader_cb,
 524 /* SIPE_BUDDY_MENU_REMOVE_FROM_CHAT    */ sipe_purple_buddy_remove_from_chat_cb,
 525 /* SIPE_BUDDY_MENU_INVITE_TO_CHAT      */ sipe_purple_buddy_invite_to_chat_cb,
 526 /* SIPE_BUDDY_MENU_NEW_CHAT            */ sipe_purple_buddy_new_chat_cb,
 527 /* SIPE_BUDDY_MENU_MAKE_CALL           */ sipe_purple_buddy_make_call_cb,
 528 /* SIPE_BUDDY_MENU_SEND_EMAIL          */ sipe_purple_buddy_send_email_cb,
 529 /* SIPE_BUDDY_MENU_ACCESS_LEVEL_HELP   */ sipe_purple_buddy_access_level_help_cb,
 530 /* SIPE_BUDDY_MENU_CHANGE_ACCESS_LEVEL */ sipe_purple_buddy_change_access_level_cb,
 531 /* SIPE_BUDDY_MENU_ADD_NEW_DOMAIN      */ sipe_purple_buddy_add_new_domain_cb,
 532 };
 533
 534 struct sipe_backend_buddy_menu *sipe_backend_buddy_menu_start(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public)
 535 {
 536         return(NULL);
 537 }
 538
 539 struct sipe_backend_buddy_menu *sipe_backend_buddy_menu_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 540                                                             struct sipe_backend_buddy_menu *menu,
 541                                                             const gchar *label,
 542                                                             enum sipe_buddy_menu_type type,
 543                                                             gpointer parameter)
 544 {
 545         return((struct sipe_backend_buddy_menu *)
 546                g_list_prepend((GList *) menu,
 547                               purple_menu_action_new(label,
 548                                                      PURPLE_CALLBACK(callback_map[type]),
 549                                                      parameter, NULL)));
 550 }
 551
 552 struct sipe_backend_buddy_menu *sipe_backend_buddy_menu_separator(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 553                                                                   struct sipe_backend_buddy_menu *menu,
 554                                                                   const gchar *label)
 555 {
 556         return((struct sipe_backend_buddy_menu *)
 557                g_list_prepend((GList *) menu,
 558                               purple_menu_action_new(label, NULL, NULL, NULL)));
 559 }
 560
 561 struct sipe_backend_buddy_menu *sipe_backend_buddy_sub_menu_add(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 562                                                                 struct sipe_backend_buddy_menu *menu,
 563                                                                 const gchar *label,
 564                                                                 struct sipe_backend_buddy_menu *sub)
 565 {
 566         return((struct sipe_backend_buddy_menu *)
 567                g_list_prepend((GList *) menu,
 568                               purple_menu_action_new(label,
 569                                                      NULL,
 570                                                      NULL,
 571                                                      g_list_reverse((GList *) sub))));
 572 }
 573
 574 static void sipe_purple_buddy_copy_to_cb(PurpleBlistNode *node,
 575                                          const gchar *group_name)
 576 {
 577         struct sipe_core_public *sipe_public;
 578         PurpleBuddy *buddy = (PurpleBuddy *)node;
 579         PurpleGroup *group;
 580         PurpleBuddy *clone;
 581
 582         g_return_if_fail(PURPLE_BLIST_NODE_IS_BUDDY(node));
 583
 584         sipe_public = PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC;
 585         group       = purple_find_group(group_name);
 586
 587         SIPE_DEBUG_INFO("sipe_purple_buddy_copy_to_cb: copying %s to %s",
 588                         buddy->name, group_name);
 589
 590         clone = purple_find_buddy_in_group(buddy->account, buddy->name, group);
 591         if (!clone) {
 592                 clone = sipe_backend_buddy_add(sipe_public,
 593                                                buddy->name,
 594                                                buddy->alias,
 595                                                group->name);
 596                 if (clone) {
 597                         const gchar *tmp;
 598                         const gchar *key;
 599                         const PurpleStatus *status = purple_presence_get_active_status(purple_buddy_get_presence(buddy));
 600
 601                         tmp = purple_buddy_get_server_alias(buddy);
 602                         if (tmp) purple_blist_server_alias_buddy(clone, tmp);
 603
 604                         key = buddy_info_property(SIPE_BUDDY_INFO_EMAIL);
 605                         tmp = purple_blist_node_get_string(&buddy->node, key);
 606                         if (tmp) purple_blist_node_set_string(&clone->node,
 607                                                               key,
 608                                                               tmp);
 609
 610                         tmp = purple_status_get_id(status);
 611                         purple_presence_set_status_active(purple_buddy_get_presence(clone),
 612                                                           tmp,
 613                                                           TRUE);
 614
 615                         /* update UI */
 616                         purple_prpl_got_user_status(clone->account,
 617                                                     clone->name,
 618                                                     tmp,
 619                                                     NULL);
 620                 }
 621         }
 622
 623         if (clone && group)
 624                 sipe_core_buddy_add(sipe_public,
 625                                     clone->name,
 626                                     group->name);
 627 }
 628
 629 static GList *sipe_purple_copy_to_menu(GList *menu,
 630                                        PurpleBuddy *buddy)
 631 {
 632         GList *menu_groups = NULL;
 633         PurpleGroup *gr_parent = purple_buddy_get_group(buddy);
 634         PurpleBlistNode *g_node;
 635
 636         for (g_node = purple_blist_get_root(); g_node; g_node = g_node->next) {
 637                 PurpleGroup *group = (PurpleGroup *)g_node;
 638                 PurpleMenuAction *act;
 639
 640                 if ((g_node->type != PURPLE_BLIST_GROUP_NODE) ||
 641                     (group == gr_parent)                      ||
 642                     purple_find_buddy_in_group(buddy->account,
 643                                                buddy->name,
 644                                                group))
 645                         continue;
 646
 647                 act = purple_menu_action_new(purple_group_get_name(group),
 648                                              PURPLE_CALLBACK(sipe_purple_buddy_copy_to_cb),
 649                                              group->name, NULL);
 650                 menu_groups = g_list_prepend(menu_groups, act);
 651         }
 652
 653         if (menu_groups)
 654                 menu = g_list_prepend(menu,
 655                                       purple_menu_action_new(_("Copy to"),
 656                                                              NULL,
 657                                                              NULL,
 658                                                              g_list_reverse(menu_groups)));
 659
 660         return(menu);
 661 }
 662
 663 GList *sipe_purple_buddy_menu(PurpleBuddy *buddy)
 664 {
 665         struct sipe_core_public *sipe_public = PURPLE_BUDDY_TO_SIPE_CORE_PUBLIC;
 666         GList *menu = (GList *) sipe_core_buddy_create_menu(sipe_public,
 667                                                             buddy->name,
 668                                                             NULL);
 669         menu = sipe_purple_copy_to_menu(menu, buddy);
 670         return(g_list_reverse(menu));
 671 }
 672
 673
 674 /*
 675   Local Variables:
 676   mode: c
 677   c-file-style: "bsd"
 678   indent-tabs-mode: t
 679   tab-width: 8
 680   End:
 681 */