2 * Copyright (C) 2010 Collabora Ltd.
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.
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.
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
19 * Authors: Philip Withnall <philip.withnall@collabora.co.uk>
26 #include <glib/gi18n-lib.h>
29 #include <telepathy-glib/util.h>
31 #include <folks/folks.h>
33 #include <libempathy/empathy-individual-manager.h>
34 #include <libempathy/empathy-utils.h>
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"
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
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.
55 * EmpathyIndividualLinker:
56 * @parent: parent object
58 * Widget which extends #GtkBin to provide a list of #FolksIndividual<!-- -->s
62 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIndividualLinker)
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 */
73 FolksIndividual *start_individual; /* owned, allow-none */
74 FolksIndividual *new_individual; /* owned, allow-none */
76 /* Stores the Individuals whose Personas have been added to the
78 /* unowned Individual (borrowed from EmpathyIndividualStore) -> bool */
79 GHashTable *changed_individuals;
80 } EmpathyIndividualLinkerPriv;
83 PROP_START_INDIVIDUAL = 1,
87 G_DEFINE_TYPE (EmpathyIndividualLinker, empathy_individual_linker,
91 contact_toggle_cell_data_func (GtkTreeViewColumn *tree_column,
92 GtkCellRenderer *cell,
93 GtkTreeModel *tree_model,
95 EmpathyIndividualLinker *self)
97 EmpathyIndividualLinkerPriv *priv;
98 FolksIndividual *individual;
99 gboolean is_group, individual_added;
101 priv = GET_PRIV (self);
103 gtk_tree_model_get (tree_model, iter,
104 EMPATHY_INDIVIDUAL_STORE_COL_IS_GROUP, &is_group,
105 EMPATHY_INDIVIDUAL_STORE_COL_INDIVIDUAL, &individual,
108 individual_added = GPOINTER_TO_UINT (g_hash_table_lookup (
109 priv->changed_individuals, individual));
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 */
115 "visible", !is_group,
116 "sensitive", individual != priv->start_individual,
117 "activatable", individual != priv->start_individual,
118 "active", individual_added || individual == priv->start_individual,
121 tp_clear_object (&individual);
125 update_toggle_renderers (EmpathyIndividualLinker *self)
127 EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
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);
140 link_individual (EmpathyIndividualLinker *self,
141 FolksIndividual *individual)
143 EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
144 GeeSet *old_personas, *new_personas;
145 GeeHashSet *final_personas;
146 gboolean personas_changed;
148 /* Add the individual to the link */
149 g_hash_table_insert (priv->changed_individuals, individual,
150 GUINT_TO_POINTER (TRUE));
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));
163 /* avoid updating all values in the Individual if the set of personas doesn't
165 if (personas_changed)
167 folks_individual_set_personas (priv->new_individual,
168 GEE_SET (final_personas));
171 g_clear_object (&final_personas);
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);
178 g_object_notify (G_OBJECT (self), "has-changed");
182 unlink_individual (EmpathyIndividualLinker *self,
183 FolksIndividual *individual)
185 EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
186 GeeSet *removed_personas, *old_personas;
187 GeeHashSet *final_personas;
188 gboolean personas_changed;
190 /* Remove the individual from the link */
191 g_hash_table_remove (priv->changed_individuals, individual);
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);
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));
204 if (personas_changed)
206 folks_individual_set_personas (priv->new_individual,
207 GEE_SET (final_personas));
210 g_clear_object (&final_personas);
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);
217 g_object_notify (G_OBJECT (self), "has-changed");
221 toggle_individual_row (EmpathyIndividualLinker *self,
224 EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
225 FolksIndividual *individual;
227 GtkTreeModel *tree_model;
228 gboolean individual_added;
230 tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->individual_view));
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,
237 if (individual == NULL)
240 individual_added = GPOINTER_TO_UINT (g_hash_table_lookup (
241 priv->changed_individuals, individual));
243 /* Toggle the Individual's linked status */
244 if (individual_added)
245 unlink_individual (self, individual);
247 link_individual (self, individual);
249 g_object_unref (individual);
253 row_activated_cb (EmpathyIndividualView *view,
255 GtkTreeViewColumn *column,
256 EmpathyIndividualLinker *self)
258 toggle_individual_row (self, path);
262 row_toggled_cb (GtkCellRendererToggle *cell_renderer,
264 EmpathyIndividualLinker *self)
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);
272 individual_view_drag_motion_cb (GtkWidget *widget,
273 GdkDragContext *context,
278 EmpathyIndividualView *view = EMPATHY_INDIVIDUAL_VIEW (widget);
281 target = gtk_drag_dest_find_target (GTK_WIDGET (view), context, NULL);
283 if (target == gdk_atom_intern_static_string ("text/x-persona-id"))
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),
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);
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);
310 individual_view_drag_persona_received_cb (EmpathyIndividualView *view,
311 GdkDragAction action,
312 FolksPersona *persona,
313 FolksIndividual *individual,
314 EmpathyIndividualLinker *self)
316 EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
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)
323 unlink_individual (self, individual);
331 persona_view_drag_individual_received_cb (EmpathyPersonaView *view,
332 GdkDragAction action,
333 FolksIndividual *individual,
334 EmpathyIndividualLinker *self)
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);
344 set_up (EmpathyIndividualLinker *self)
346 EmpathyIndividualLinkerPriv *priv;
347 EmpathyIndividualManager *individual_manager;
350 GtkWidget *label, *scrolled_window;
352 EmpathyPersonaView *persona_view;
354 GtkWidget *alignment;
356 priv = GET_PRIV (self);
358 top_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
362 paned = GTK_PANED (gtk_paned_new (GTK_ORIENTATION_HORIZONTAL));
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);
369 vbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 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);
374 gtk_box_pack_start (vbox, label, FALSE, TRUE, 0);
375 gtk_widget_show (label);
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);
382 empathy_individual_store_set_show_protocols (priv->individual_store, FALSE);
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);
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);
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);
404 priv->toggle_column = gtk_tree_view_column_new ();
405 gtk_tree_view_column_pack_start (priv->toggle_column, priv->toggle_renderer,
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);
411 gtk_tree_view_insert_column (GTK_TREE_VIEW (priv->individual_view),
412 priv->toggle_column, 0);
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),
419 gtk_container_add (GTK_CONTAINER (scrolled_window),
420 GTK_WIDGET (priv->individual_view));
421 gtk_widget_show (GTK_WIDGET (priv->individual_view));
423 gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0);
424 gtk_widget_show (scrolled_window);
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));
432 gtk_box_pack_end (vbox, priv->search_widget, FALSE, TRUE, 0);
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));
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);
443 vbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 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);
448 gtk_box_pack_start (vbox, label, FALSE, TRUE, 0);
449 gtk_widget_show (label);
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);
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),
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);
470 g_signal_connect (persona_view, "drag-individual-received",
471 (GCallback) persona_view_drag_individual_received_cb, self);
473 gtk_container_add (GTK_CONTAINER (scrolled_window),
474 GTK_WIDGET (persona_view));
475 gtk_widget_show (GTK_WIDGET (persona_view));
477 gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0);
478 gtk_widget_show (scrolled_window);
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));
484 gtk_widget_show (GTK_WIDGET (paned));
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);
492 gtk_widget_show (label);
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);
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));
503 empathy_individual_linker_init (EmpathyIndividualLinker *self)
505 EmpathyIndividualLinkerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
506 EMPATHY_TYPE_INDIVIDUAL_LINKER, EmpathyIndividualLinkerPriv);
510 priv->changed_individuals = g_hash_table_new (NULL, NULL);
516 get_property (GObject *object,
521 EmpathyIndividualLinkerPriv *priv;
523 priv = GET_PRIV (object);
527 case PROP_START_INDIVIDUAL:
528 g_value_set_object (value, priv->start_individual);
530 case PROP_HAS_CHANGED:
531 g_value_set_boolean (value, empathy_individual_linker_get_has_changed (
532 EMPATHY_INDIVIDUAL_LINKER (object)));
535 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
541 set_property (GObject *object,
548 case PROP_START_INDIVIDUAL:
549 empathy_individual_linker_set_start_individual (
550 EMPATHY_INDIVIDUAL_LINKER (object), g_value_get_object (value));
553 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
559 dispose (GObject *object)
561 EmpathyIndividualLinkerPriv *priv = GET_PRIV (object);
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);
568 G_OBJECT_CLASS (empathy_individual_linker_parent_class)->dispose (object);
572 finalize (GObject *object)
574 EmpathyIndividualLinkerPriv *priv = GET_PRIV (object);
576 g_hash_table_unref (priv->changed_individuals);
578 G_OBJECT_CLASS (empathy_individual_linker_parent_class)->finalize (object);
582 empathy_individual_linker_class_init (EmpathyIndividualLinkerClass *klass)
584 GObjectClass *object_class = G_OBJECT_CLASS (klass);
586 object_class->get_property = get_property;
587 object_class->set_property = set_property;
588 object_class->dispose = dispose;
589 object_class->finalize = finalize;
592 * EmpathyIndividualLinker:start-individual:
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.
599 g_object_class_install_property (object_class, PROP_START_INDIVIDUAL,
600 g_param_spec_object ("start-individual",
602 "The #FolksIndividual to link other individuals to.",
603 FOLKS_TYPE_INDIVIDUAL,
604 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
607 * EmpathyIndividualLinker:has-changed:
609 * Whether #FolksIndividual<!-- -->s have been added to or removed from
610 * the linked individual currently displayed in the widget.
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.
616 g_object_class_install_property (object_class, PROP_HAS_CHANGED,
617 g_param_spec_boolean ("has-changed",
619 "Whether individuals have been added to or removed from the linked "
620 "individual currently displayed in the widget.",
622 G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
624 g_type_class_add_private (object_class, sizeof (EmpathyIndividualLinkerPriv));
628 * empathy_individual_linker_new:
629 * @start_individual: (allow-none): the #FolksIndividual to link to, or %NULL
631 * Creates a new #EmpathyIndividualLinker.
633 * Return value: a new #EmpathyIndividualLinker
636 empathy_individual_linker_new (FolksIndividual *start_individual)
638 g_return_val_if_fail (start_individual == NULL ||
639 FOLKS_IS_INDIVIDUAL (start_individual), NULL);
641 return g_object_new (EMPATHY_TYPE_INDIVIDUAL_LINKER,
642 "start-individual", start_individual,
647 * empathy_individual_linker_get_start_individual:
648 * @self: an #EmpathyIndividualLinker
650 * Get the value of #EmpathyIndividualLinker:start-individual.
652 * Return value: (transfer none): the start individual for linking, or %NULL
655 empathy_individual_linker_get_start_individual (EmpathyIndividualLinker *self)
657 g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self), NULL);
659 return GET_PRIV (self)->start_individual;
663 * empathy_individual_linker_set_start_individual:
664 * @self: an #EmpathyIndividualLinker
665 * @individual: (allow-none): the start individual, or %NULL
667 * Set the value of #EmpathyIndividualLinker:start-individual to @individual.
670 empathy_individual_linker_set_start_individual (EmpathyIndividualLinker *self,
671 FolksIndividual *individual)
673 EmpathyIndividualLinkerPriv *priv;
675 g_return_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self));
676 g_return_if_fail (individual == NULL || FOLKS_IS_INDIVIDUAL (individual));
678 priv = GET_PRIV (self);
680 tp_clear_object (&priv->start_individual);
681 tp_clear_object (&priv->new_individual);
682 g_hash_table_remove_all (priv->changed_individuals);
684 if (individual != NULL)
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);
694 priv->start_individual = NULL;
695 priv->new_individual = NULL;
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);
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);
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));
714 * empathy_individual_linker_get_linked_personas:
715 * @self: an #EmpathyIndividualLinker
717 * Return a list of the #FolksPersona<!-- -->s which comprise the linked
718 * individual currently displayed in the widget.
720 * The return value is guaranteed to contain at least one element.
722 * Return value: (transfer none) (element-type Folks.Persona): a set of
723 * #FolksPersona<!-- -->s to link together
726 empathy_individual_linker_get_linked_personas (EmpathyIndividualLinker *self)
728 EmpathyIndividualLinkerPriv *priv;
731 g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self), NULL);
733 priv = GET_PRIV (self);
735 if (priv->new_individual == NULL)
738 personas = folks_individual_get_personas (priv->new_individual);
739 g_assert (personas != NULL);
744 * empathy_individual_linker_get_has_changed:
745 * @self: an #EmpathyIndividualLinker
747 * Return whether #FolksIndividual<!-- -->s have been added to or removed from
748 * the linked individual currently displayed in the widget.
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.
754 * Return value: %TRUE if the linked individual has been changed, %FALSE
758 empathy_individual_linker_get_has_changed (EmpathyIndividualLinker *self)
760 EmpathyIndividualLinkerPriv *priv;
762 g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self), FALSE);
764 priv = GET_PRIV (self);
766 return (g_hash_table_size (priv->changed_individuals) > 0) ? TRUE : FALSE;
770 empathy_individual_linker_set_search_text (EmpathyIndividualLinker *self,
771 const gchar *search_text)
773 g_return_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self));
775 empathy_live_search_set_text (
776 EMPATHY_LIVE_SEARCH (GET_PRIV (self)->search_widget), search_text);