libempathy-gtk/empathy-individual-linker.c

   1 /*
   2  * Copyright (C) 2010 Collabora Ltd.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public
  15  * License along with this program; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA  02110-1301  USA
  18  *
  19  * Authors: Philip Withnall <philip.withnall@collabora.co.uk>
  20  */
  21
  22 #include "config.h"
  23
  24 #include <string.h>
  25
  26 #include <glib/gi18n-lib.h>
  27 #include <gtk/gtk.h>
  28
  29 #include <telepathy-glib/util.h>
  30
  31 #include <folks/folks.h>
  32
  33 #include <libempathy/empathy-individual-manager.h>
  34 #include <libempathy/empathy-utils.h>
  35
  36 #include "empathy-individual-linker.h"
  37 #include "empathy-individual-store.h"
  38 #include "empathy-individual-view.h"
  39 #include "empathy-individual-widget.h"
  40 #include "empathy-persona-store.h"
  41 #include "empathy-persona-view.h"
  42
  43 /**
  44  * SECTION:empathy-individual-linker
  45  * @title:EmpathyIndividualLinker
  46  * @short_description: A widget used to link together #FolksIndividual<!-- -->s
  47  * @include: libempathy-gtk/empathy-individual-linker.h
  48  *
  49  * #EmpathyIndividualLinker is a widget which allows selection of several
  50  * #FolksIndividual<!-- -->s to link together to form a single new individual.
  51  * The widget provides a preview of the linked individual.
  52  */
  53
  54 /**
  55  * EmpathyIndividualLinker:
  56  * @parent: parent object
  57  *
  58  * Widget which extends #GtkBin to provide a list of #FolksIndividual<!-- -->s
  59  * to link together.
  60  */
  61
  62 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIndividualLinker)
  63
  64 typedef struct {
  65   EmpathyIndividualStore *individual_store; /* owned */
  66   EmpathyIndividualView *individual_view; /* child widget */
  67   GtkWidget *preview_widget; /* child widget */
  68   EmpathyPersonaStore *persona_store; /* owned */
  69   GtkTreeViewColumn *toggle_column; /* child widget */
  70   GtkCellRenderer *toggle_renderer; /* child widget */
  71   GtkWidget *search_widget; /* child widget */
  72
  73   FolksIndividual *start_individual; /* owned, allow-none */
  74   FolksIndividual *new_individual; /* owned, allow-none */
  75
  76   /* Stores the Individuals whose Personas have been added to the
  77    * new_individual */
  78   /* unowned Individual (borrowed from EmpathyIndividualStore) -> bool */
  79   GHashTable *changed_individuals;
  80 } EmpathyIndividualLinkerPriv;
  81
  82 enum {
  83   PROP_START_INDIVIDUAL = 1,
  84   PROP_HAS_CHANGED,
  85 };
  86
  87 G_DEFINE_TYPE (EmpathyIndividualLinker, empathy_individual_linker,
  88     GTK_TYPE_BOX);
  89
  90 static void
  91 contact_toggle_cell_data_func (GtkTreeViewColumn *tree_column,
  92     GtkCellRenderer *cell,
  93     GtkTreeModel *tree_model,
  94     GtkTreeIter *iter,
  95     EmpathyIndividualLinker *self)
  96 {
  97   EmpathyIndividualLinkerPriv *priv;
  98   FolksIndividual *individual;
  99   gboolean is_group, individual_added;
 100
 101   priv = GET_PRIV (self);
 102
 103   gtk_tree_model_get (tree_model, iter,
 104       EMPATHY_INDIVIDUAL_STORE_COL_IS_GROUP, &is_group,
 105       EMPATHY_INDIVIDUAL_STORE_COL_INDIVIDUAL, &individual,
 106       -1);
 107
 108   individual_added = GPOINTER_TO_UINT (g_hash_table_lookup (
 109       priv->changed_individuals, individual));
 110
 111   /* We don't want to show checkboxes next to the group rows.
 112    * All checkboxes should be sensitive except the checkbox for the start
 113    * individual, which should be permanently active and insensitive */
 114   g_object_set (cell,
 115       "visible", !is_group,
 116       "sensitive", individual != priv->start_individual,
 117       "activatable", individual != priv->start_individual,
 118       "active", individual_added || individual == priv->start_individual,
 119       NULL);
 120
 121   tp_clear_object (&individual);
 122 }
 123
 124 static void
 125 update_toggle_renderers (EmpathyIndividualLinker *self)
 126 {
 127   EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
 128
 129   /* Re-setting the cell data func to the same function causes a refresh of the
 130    * entire column, ensuring that each toggle button is correctly active or
 131    * inactive. This is necessary because one Individual might appear multiple
 132    * times in the list (in different groups), so toggling one instance of the
 133    * Individual should toggle all of them. */
 134   gtk_tree_view_column_set_cell_data_func (priv->toggle_column,
 135       priv->toggle_renderer,
 136       (GtkTreeCellDataFunc) contact_toggle_cell_data_func, self, NULL);
 137 }
 138
 139 static void
 140 link_individual (EmpathyIndividualLinker *self,
 141     FolksIndividual *individual)
 142 {
 143   EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
 144   GeeSet *old_personas, *new_personas;
 145   GeeHashSet *final_personas;
 146   gboolean personas_changed;
 147
 148   /* Add the individual to the link */
 149   g_hash_table_insert (priv->changed_individuals, individual,
 150       GUINT_TO_POINTER (TRUE));
 151
 152   /* Add personas which are in @individual to priv->new_individual, adding them
 153    * to the set of personas. */
 154   old_personas = folks_individual_get_personas (individual);
 155   new_personas = folks_individual_get_personas (priv->new_individual);
 156   final_personas = gee_hash_set_new (FOLKS_TYPE_PERSONA, g_object_ref,
 157       g_object_unref, g_direct_hash, g_direct_equal);
 158   gee_collection_add_all (GEE_COLLECTION (final_personas),
 159       GEE_COLLECTION (old_personas));
 160   personas_changed = gee_collection_add_all (GEE_COLLECTION (final_personas),
 161       GEE_COLLECTION (new_personas));
 162
 163   /* avoid updating all values in the Individual if the set of personas doesn't
 164    * actually change */
 165   if (personas_changed)
 166     {
 167       folks_individual_set_personas (priv->new_individual,
 168           GEE_SET (final_personas));
 169     }
 170
 171   g_clear_object (&final_personas);
 172
 173   /* Update the toggle renderers, so that if this Individual is listed in
 174    * another group in the EmpathyIndividualView, the toggle button for that
 175    * group is updated. */
 176   update_toggle_renderers (self);
 177
 178   g_object_notify (G_OBJECT (self), "has-changed");
 179 }
 180
 181 static void
 182 unlink_individual (EmpathyIndividualLinker *self,
 183     FolksIndividual *individual)
 184 {
 185   EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
 186   GeeSet *removed_personas, *old_personas;
 187   GeeHashSet *final_personas;
 188   gboolean personas_changed;
 189
 190   /* Remove the individual from the link */
 191   g_hash_table_remove (priv->changed_individuals, individual);
 192
 193   /* Remove personas which are in @individual from priv->new_individual. */
 194   old_personas = folks_individual_get_personas (priv->new_individual);
 195   removed_personas = folks_individual_get_personas (individual);
 196
 197   final_personas = gee_hash_set_new (FOLKS_TYPE_PERSONA, g_object_ref,
 198       g_object_unref, g_direct_hash, g_direct_equal);
 199   gee_collection_add_all (GEE_COLLECTION (final_personas),
 200       GEE_COLLECTION (old_personas));
 201   personas_changed = gee_collection_remove_all (GEE_COLLECTION (final_personas),
 202       GEE_COLLECTION (removed_personas));
 203
 204   if (personas_changed)
 205     {
 206       folks_individual_set_personas (priv->new_individual,
 207           GEE_SET (final_personas));
 208     }
 209
 210   g_clear_object (&final_personas);
 211
 212   /* Update the toggle renderers, so that if this Individual is listed in
 213    * another group in the EmpathyIndividualView, the toggle button for that
 214    * group is updated. */
 215   update_toggle_renderers (self);
 216
 217   g_object_notify (G_OBJECT (self), "has-changed");
 218 }
 219
 220 static void
 221 toggle_individual_row (EmpathyIndividualLinker *self,
 222     GtkTreePath *path)
 223 {
 224   EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
 225   FolksIndividual *individual;
 226   GtkTreeIter iter;
 227   GtkTreeModel *tree_model;
 228   gboolean individual_added;
 229
 230   tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->individual_view));
 231
 232   gtk_tree_model_get_iter (tree_model, &iter, path);
 233   gtk_tree_model_get (tree_model, &iter,
 234       EMPATHY_INDIVIDUAL_STORE_COL_INDIVIDUAL, &individual,
 235       -1);
 236
 237   if (individual == NULL)
 238     return;
 239
 240   individual_added = GPOINTER_TO_UINT (g_hash_table_lookup (
 241       priv->changed_individuals, individual));
 242
 243   /* Toggle the Individual's linked status */
 244   if (individual_added)
 245     unlink_individual (self, individual);
 246   else
 247     link_individual (self, individual);
 248
 249   g_object_unref (individual);
 250 }
 251
 252 static void
 253 row_activated_cb (EmpathyIndividualView *view,
 254     GtkTreePath *path,
 255     GtkTreeViewColumn *column,
 256     EmpathyIndividualLinker *self)
 257 {
 258   toggle_individual_row (self, path);
 259 }
 260
 261 static void
 262 row_toggled_cb (GtkCellRendererToggle *cell_renderer,
 263     const gchar *path,
 264     EmpathyIndividualLinker *self)
 265 {
 266   GtkTreePath *tree_path = gtk_tree_path_new_from_string (path);
 267   toggle_individual_row (self, tree_path);
 268   gtk_tree_path_free (tree_path);
 269 }
 270
 271 static gboolean
 272 individual_view_drag_motion_cb (GtkWidget *widget,
 273     GdkDragContext *context,
 274     gint x,
 275     gint y,
 276     guint time_)
 277 {
 278   EmpathyIndividualView *view = EMPATHY_INDIVIDUAL_VIEW (widget);
 279   GdkAtom target;
 280
 281   target = gtk_drag_dest_find_target (GTK_WIDGET (view), context, NULL);
 282
 283   if (target == gdk_atom_intern_static_string ("text/x-persona-id"))
 284     {
 285       GtkTreePath *path;
 286
 287       /* FIXME: It doesn't make sense for us to highlight a specific row or
 288        * position to drop a Persona in, so just highlight the entire widget.
 289        * Since I can't find a way to do this, just highlight the first possible
 290        * position in the tree. */
 291       gdk_drag_status (context, gdk_drag_context_get_suggested_action (context),
 292           time_);
 293
 294       path = gtk_tree_path_new_first ();
 295       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (view), path,
 296           GTK_TREE_VIEW_DROP_BEFORE);
 297       gtk_tree_path_free (path);
 298
 299       return TRUE;
 300     }
 301
 302   /* Unknown or unhandled drag target */
 303   gdk_drag_status (context, GDK_ACTION_DEFAULT, time_);
 304   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (view), NULL, 0);
 305
 306   return FALSE;
 307 }
 308
 309 static gboolean
 310 individual_view_drag_persona_received_cb (EmpathyIndividualView *view,
 311     GdkDragAction action,
 312     FolksPersona *persona,
 313     FolksIndividual *individual,
 314     EmpathyIndividualLinker *self)
 315 {
 316   EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
 317
 318   /* A Persona has been dragged onto the EmpathyIndividualView (from the
 319    * EmpathyPersonaView), so we try to remove the Individual which contains
 320    * the Persona from the link. */
 321   if (individual != priv->start_individual)
 322     {
 323       unlink_individual (self, individual);
 324       return TRUE;
 325     }
 326
 327   return FALSE;
 328 }
 329
 330 static gboolean
 331 persona_view_drag_individual_received_cb (EmpathyPersonaView *view,
 332     GdkDragAction action,
 333     FolksIndividual *individual,
 334     EmpathyIndividualLinker *self)
 335 {
 336   /* An Individual has been dragged onto the EmpathyPersonaView (from the
 337    * EmpathyIndividualView), so we try to add the Individual to the link. */
 338   link_individual (self, individual);
 339
 340   return TRUE;
 341 }
 342
 343 static void
 344 set_up (EmpathyIndividualLinker *self)
 345 {
 346   EmpathyIndividualLinkerPriv *priv;
 347   EmpathyIndividualManager *individual_manager;
 348   GtkWidget *top_vbox;
 349   GtkPaned *paned;
 350   GtkWidget *label, *scrolled_window;
 351   GtkBox *vbox;
 352   EmpathyPersonaView *persona_view;
 353   gchar *tmp;
 354   GtkWidget *alignment;
 355
 356   priv = GET_PRIV (self);
 357
 358   top_vbox = gtk_vbox_new (FALSE, 6);
 359
 360   /* Layout panes */
 361
 362   paned = GTK_PANED (gtk_paned_new (GTK_ORIENTATION_HORIZONTAL));
 363
 364   /* Left column heading */
 365   alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
 366   gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 0, 6);
 367   gtk_widget_show (alignment);
 368
 369   vbox = GTK_BOX (gtk_vbox_new (FALSE, 6));
 370   label = gtk_label_new (NULL);
 371   tmp = g_strdup_printf ("<b>%s</b>", _("Select contacts to link"));
 372   gtk_label_set_markup (GTK_LABEL (label), tmp);
 373   g_free (tmp);
 374   gtk_box_pack_start (vbox, label, FALSE, TRUE, 0);
 375   gtk_widget_show (label);
 376
 377   /* Individual selector */
 378   individual_manager = empathy_individual_manager_dup_singleton ();
 379   priv->individual_store = empathy_individual_store_new (individual_manager);
 380   g_object_unref (individual_manager);
 381
 382   empathy_individual_store_set_show_protocols (priv->individual_store, FALSE);
 383
 384   priv->individual_view = empathy_individual_view_new (priv->individual_store,
 385       EMPATHY_INDIVIDUAL_VIEW_FEATURE_INDIVIDUAL_DRAG |
 386       EMPATHY_INDIVIDUAL_VIEW_FEATURE_INDIVIDUAL_DROP |
 387       EMPATHY_INDIVIDUAL_VIEW_FEATURE_PERSONA_DROP,
 388       EMPATHY_INDIVIDUAL_FEATURE_NONE);
 389   empathy_individual_view_set_show_offline (priv->individual_view, TRUE);
 390   empathy_individual_view_set_show_untrusted (priv->individual_view, FALSE);
 391
 392   g_signal_connect (priv->individual_view, "row-activated",
 393       (GCallback) row_activated_cb, self);
 394   g_signal_connect (priv->individual_view, "drag-motion",
 395       (GCallback) individual_view_drag_motion_cb, self);
 396   g_signal_connect (priv->individual_view, "drag-persona-received",
 397       (GCallback) individual_view_drag_persona_received_cb, self);
 398
 399   /* Add a checkbox column to the selector */
 400   priv->toggle_renderer = gtk_cell_renderer_toggle_new ();
 401   g_signal_connect (priv->toggle_renderer, "toggled",
 402       (GCallback) row_toggled_cb, self);
 403
 404   priv->toggle_column = gtk_tree_view_column_new ();
 405   gtk_tree_view_column_pack_start (priv->toggle_column, priv->toggle_renderer,
 406       FALSE);
 407   gtk_tree_view_column_set_cell_data_func (priv->toggle_column,
 408       priv->toggle_renderer,
 409       (GtkTreeCellDataFunc) contact_toggle_cell_data_func, self, NULL);
 410
 411   gtk_tree_view_insert_column (GTK_TREE_VIEW (priv->individual_view),
 412       priv->toggle_column, 0);
 413
 414   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 415   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
 416       GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 417   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
 418       GTK_SHADOW_IN);
 419   gtk_container_add (GTK_CONTAINER (scrolled_window),
 420       GTK_WIDGET (priv->individual_view));
 421   gtk_widget_show (GTK_WIDGET (priv->individual_view));
 422
 423   gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0);
 424   gtk_widget_show (scrolled_window);
 425
 426   /* Live search */
 427   priv->search_widget = empathy_live_search_new (
 428       GTK_WIDGET (priv->individual_view));
 429   empathy_individual_view_set_live_search (priv->individual_view,
 430       EMPATHY_LIVE_SEARCH (priv->search_widget));
 431
 432   gtk_box_pack_end (vbox, priv->search_widget, FALSE, TRUE, 0);
 433
 434   gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox));
 435   gtk_paned_pack1 (paned, alignment, TRUE, FALSE);
 436   gtk_widget_show (GTK_WIDGET (vbox));
 437
 438   /* Right column heading */
 439   alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
 440   gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 6, 0);
 441   gtk_widget_show (alignment);
 442
 443   vbox = GTK_BOX (gtk_vbox_new (FALSE, 6));
 444   label = gtk_label_new (NULL);
 445   tmp = g_strdup_printf ("<b>%s</b>", _("New contact preview"));
 446   gtk_label_set_markup (GTK_LABEL (label), tmp);
 447   g_free (tmp);
 448   gtk_box_pack_start (vbox, label, FALSE, TRUE, 0);
 449   gtk_widget_show (label);
 450
 451   /* New individual preview */
 452   priv->preview_widget = empathy_individual_widget_new (priv->new_individual,
 453       EMPATHY_INDIVIDUAL_WIDGET_SHOW_DETAILS);
 454   gtk_box_pack_start (vbox, priv->preview_widget, FALSE, TRUE, 0);
 455   gtk_widget_show (priv->preview_widget);
 456
 457   /* Persona list */
 458   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 459   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
 460       GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 461   gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
 462       GTK_SHADOW_IN);
 463
 464   priv->persona_store = empathy_persona_store_new (priv->new_individual);
 465   empathy_persona_store_set_show_protocols (priv->persona_store, TRUE);
 466   persona_view = empathy_persona_view_new (priv->persona_store,
 467       EMPATHY_PERSONA_VIEW_FEATURE_ALL);
 468   empathy_persona_view_set_show_offline (persona_view, TRUE);
 469
 470   g_signal_connect (persona_view, "drag-individual-received",
 471       (GCallback) persona_view_drag_individual_received_cb, self);
 472
 473   gtk_container_add (GTK_CONTAINER (scrolled_window),
 474       GTK_WIDGET (persona_view));
 475   gtk_widget_show (GTK_WIDGET (persona_view));
 476
 477   gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0);
 478   gtk_widget_show (scrolled_window);
 479
 480   gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox));
 481   gtk_paned_pack2 (paned, alignment, TRUE, FALSE);
 482   gtk_widget_show (GTK_WIDGET (vbox));
 483
 484   gtk_widget_show (GTK_WIDGET (paned));
 485
 486   /* Footer label */
 487   label = gtk_label_new (NULL);
 488   tmp = g_strdup_printf ("<i>%s</i>",
 489       _("Contacts selected in the list on the left will be linked together."));
 490   gtk_label_set_markup (GTK_LABEL (label), tmp);
 491   g_free (tmp);
 492   gtk_widget_show (label);
 493
 494   gtk_box_pack_start (GTK_BOX (top_vbox), GTK_WIDGET (paned), TRUE, TRUE, 0);
 495   gtk_box_pack_start (GTK_BOX (top_vbox), label, FALSE, TRUE, 0);
 496
 497   /* Add the main vbox to the bin */
 498   gtk_box_pack_start (GTK_BOX (self), GTK_WIDGET (top_vbox), TRUE, TRUE, 0);
 499   gtk_widget_show (GTK_WIDGET (top_vbox));
 500 }
 501
 502 static void
 503 empathy_individual_linker_init (EmpathyIndividualLinker *self)
 504 {
 505   EmpathyIndividualLinkerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 506       EMPATHY_TYPE_INDIVIDUAL_LINKER, EmpathyIndividualLinkerPriv);
 507
 508   self->priv = priv;
 509
 510   priv->changed_individuals = g_hash_table_new (NULL, NULL);
 511
 512   set_up (self);
 513 }
 514
 515 static void
 516 get_property (GObject *object,
 517     guint param_id,
 518     GValue *value,
 519     GParamSpec *pspec)
 520 {
 521   EmpathyIndividualLinkerPriv *priv;
 522
 523   priv = GET_PRIV (object);
 524
 525   switch (param_id)
 526     {
 527       case PROP_START_INDIVIDUAL:
 528         g_value_set_object (value, priv->start_individual);
 529         break;
 530       case PROP_HAS_CHANGED:
 531         g_value_set_boolean (value, empathy_individual_linker_get_has_changed (
 532             EMPATHY_INDIVIDUAL_LINKER (object)));
 533         break;
 534       default:
 535         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 536         break;
 537     }
 538 }
 539
 540 static void
 541 set_property (GObject *object,
 542     guint param_id,
 543     const GValue *value,
 544     GParamSpec *pspec)
 545 {
 546   switch (param_id)
 547     {
 548       case PROP_START_INDIVIDUAL:
 549         empathy_individual_linker_set_start_individual (
 550             EMPATHY_INDIVIDUAL_LINKER (object), g_value_get_object (value));
 551         break;
 552       default:
 553         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 554         break;
 555     }
 556 }
 557
 558 static void
 559 dispose (GObject *object)
 560 {
 561   EmpathyIndividualLinkerPriv *priv = GET_PRIV (object);
 562
 563   tp_clear_object (&priv->individual_store);
 564   tp_clear_object (&priv->persona_store);
 565   tp_clear_object (&priv->start_individual);
 566   tp_clear_object (&priv->new_individual);
 567
 568   G_OBJECT_CLASS (empathy_individual_linker_parent_class)->dispose (object);
 569 }
 570
 571 static void
 572 finalize (GObject *object)
 573 {
 574   EmpathyIndividualLinkerPriv *priv = GET_PRIV (object);
 575
 576   g_hash_table_unref (priv->changed_individuals);
 577
 578   G_OBJECT_CLASS (empathy_individual_linker_parent_class)->finalize (object);
 579 }
 580
 581 static void
 582 empathy_individual_linker_class_init (EmpathyIndividualLinkerClass *klass)
 583 {
 584   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 585
 586   object_class->get_property = get_property;
 587   object_class->set_property = set_property;
 588   object_class->dispose = dispose;
 589   object_class->finalize = finalize;
 590
 591   /**
 592    * EmpathyIndividualLinker:start-individual:
 593    *
 594    * The #FolksIndividual to link other individuals to. This individual is
 595    * selected by default in the list of individuals, and cannot be unselected.
 596    * This ensures that empathy_individual_linker_get_linked_personas() will
 597    * always return at least one persona to link.
 598    */
 599   g_object_class_install_property (object_class, PROP_START_INDIVIDUAL,
 600       g_param_spec_object ("start-individual",
 601           "Start Individual",
 602           "The #FolksIndividual to link other individuals to.",
 603           FOLKS_TYPE_INDIVIDUAL,
 604           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 605
 606   /**
 607    * EmpathyIndividualLinker:has-changed:
 608    *
 609    * Whether #FolksIndividual<!-- -->s have been added to or removed from
 610    * the linked individual currently displayed in the widget.
 611    *
 612    * This will be %FALSE after the widget is initialised, and set to %TRUE when
 613    * an individual is checked in the individual view on the left of the widget.
 614    * If the individual is later unchecked, this will be reset to %FALSE, etc.
 615    */
 616   g_object_class_install_property (object_class, PROP_HAS_CHANGED,
 617       g_param_spec_boolean ("has-changed",
 618           "Changed?",
 619           "Whether individuals have been added to or removed from the linked "
 620           "individual currently displayed in the widget.",
 621           FALSE,
 622           G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
 623
 624   g_type_class_add_private (object_class, sizeof (EmpathyIndividualLinkerPriv));
 625 }
 626
 627 /**
 628  * empathy_individual_linker_new:
 629  * @start_individual: (allow-none): the #FolksIndividual to link to, or %NULL
 630  *
 631  * Creates a new #EmpathyIndividualLinker.
 632  *
 633  * Return value: a new #EmpathyIndividualLinker
 634  */
 635 GtkWidget *
 636 empathy_individual_linker_new (FolksIndividual *start_individual)
 637 {
 638   g_return_val_if_fail (start_individual == NULL ||
 639       FOLKS_IS_INDIVIDUAL (start_individual), NULL);
 640
 641   return g_object_new (EMPATHY_TYPE_INDIVIDUAL_LINKER,
 642       "start-individual", start_individual,
 643       NULL);
 644 }
 645
 646 /**
 647  * empathy_individual_linker_get_start_individual:
 648  * @self: an #EmpathyIndividualLinker
 649  *
 650  * Get the value of #EmpathyIndividualLinker:start-individual.
 651  *
 652  * Return value: (transfer none): the start individual for linking, or %NULL
 653  */
 654 FolksIndividual *
 655 empathy_individual_linker_get_start_individual (EmpathyIndividualLinker *self)
 656 {
 657   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self), NULL);
 658
 659   return GET_PRIV (self)->start_individual;
 660 }
 661
 662 /**
 663  * empathy_individual_linker_set_start_individual:
 664  * @self: an #EmpathyIndividualLinker
 665  * @individual: (allow-none): the start individual, or %NULL
 666  *
 667  * Set the value of #EmpathyIndividualLinker:start-individual to @individual.
 668  */
 669 void
 670 empathy_individual_linker_set_start_individual (EmpathyIndividualLinker *self,
 671     FolksIndividual *individual)
 672 {
 673   EmpathyIndividualLinkerPriv *priv;
 674
 675   g_return_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self));
 676   g_return_if_fail (individual == NULL || FOLKS_IS_INDIVIDUAL (individual));
 677
 678   priv = GET_PRIV (self);
 679
 680   tp_clear_object (&priv->start_individual);
 681   tp_clear_object (&priv->new_individual);
 682   g_hash_table_remove_all (priv->changed_individuals);
 683
 684   if (individual != NULL)
 685     {
 686       priv->start_individual = g_object_ref (individual);
 687       priv->new_individual = folks_individual_new (
 688           folks_individual_get_personas (individual));
 689       empathy_individual_view_set_store (priv->individual_view,
 690           priv->individual_store);
 691     }
 692   else
 693     {
 694       priv->start_individual = NULL;
 695       priv->new_individual = NULL;
 696
 697       /* We only display Individuals in the individual view if we have a
 698        * new_individual to link them into */
 699       empathy_individual_view_set_store (priv->individual_view, NULL);
 700     }
 701
 702   empathy_individual_widget_set_individual (
 703       EMPATHY_INDIVIDUAL_WIDGET (priv->preview_widget), priv->new_individual);
 704   empathy_persona_store_set_individual (priv->persona_store,
 705       priv->new_individual);
 706
 707   g_object_freeze_notify (G_OBJECT (self));
 708   g_object_notify (G_OBJECT (self), "start-individual");
 709   g_object_notify (G_OBJECT (self), "has-changed");
 710   g_object_thaw_notify (G_OBJECT (self));
 711 }
 712
 713 /**
 714  * empathy_individual_linker_get_linked_personas:
 715  * @self: an #EmpathyIndividualLinker
 716  *
 717  * Return a list of the #FolksPersona<!-- -->s which comprise the linked
 718  * individual currently displayed in the widget.
 719  *
 720  * The return value is guaranteed to contain at least one element.
 721  *
 722  * Return value: (transfer none) (element-type Folks.Persona): a set of
 723  * #FolksPersona<!-- -->s to link together
 724  */
 725 GeeSet *
 726 empathy_individual_linker_get_linked_personas (EmpathyIndividualLinker *self)
 727 {
 728   EmpathyIndividualLinkerPriv *priv;
 729   GeeSet *personas;
 730
 731   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self), NULL);
 732
 733   priv = GET_PRIV (self);
 734
 735   if (priv->new_individual == NULL)
 736     return NULL;
 737
 738   personas = folks_individual_get_personas (priv->new_individual);
 739   g_assert (personas != NULL);
 740   return personas;
 741 }
 742
 743 /**
 744  * empathy_individual_linker_get_has_changed:
 745  * @self: an #EmpathyIndividualLinker
 746  *
 747  * Return whether #FolksIndividual<!-- -->s have been added to or removed from
 748  * the linked individual currently displayed in the widget.
 749  *
 750  * This will be %FALSE after the widget is initialised, and set to %TRUE when
 751  * an individual is checked in the individual view on the left of the widget.
 752  * If the individual is later unchecked, this will be reset to %FALSE, etc.
 753  *
 754  * Return value: %TRUE if the linked individual has been changed, %FALSE
 755  * otherwise
 756  */
 757 gboolean
 758 empathy_individual_linker_get_has_changed (EmpathyIndividualLinker *self)
 759 {
 760   EmpathyIndividualLinkerPriv *priv;
 761
 762   g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self), FALSE);
 763
 764   priv = GET_PRIV (self);
 765
 766   return (g_hash_table_size (priv->changed_individuals) > 0) ? TRUE : FALSE;
 767 }
 768
 769 void
 770 empathy_individual_linker_set_search_text (EmpathyIndividualLinker *self,
 771     const gchar *search_text)
 772 {
 773   g_return_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self));
 774
 775   empathy_live_search_set_text (
 776       EMPATHY_LIVE_SEARCH (GET_PRIV (self)->search_widget), search_text);
 777 }