don't pass a GError when first trying to start gnome-contacts
[empathy.git] / libempathy-gtk / empathy-individual-information-dialog.c
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3  * Copyright (C) 2007-2010 Collabora Ltd.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18  *
19  * Authors: Xavier Claessens <xclaesse@gmail.com>
20  *          Philip Withnall <philip.withnall@collabora.co.uk>
21  *          Travis Reitter <travis.reitter@collabora.co.uk>
22  */
23
24 #include "config.h"
25 #include "empathy-individual-information-dialog.h"
26
27 #include <glib/gi18n-lib.h>
28
29 #include "empathy-individual-manager.h"
30 #include "empathy-individual-widget.h"
31 #include "empathy-pkg-kit.h"
32 #include "empathy-ui-utils.h"
33 #include "empathy-utils.h"
34
35 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
36 #include "empathy-debug.h"
37
38 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIndividualInformationDialog)
39 typedef struct {
40   FolksIndividual *individual;
41   GtkWidget *individual_widget; /* child widget */
42   GtkWidget *label; /* child widget */
43 } EmpathyIndividualInformationDialogPriv;
44
45 enum {
46   PROP_0,
47   PROP_INDIVIDUAL,
48 };
49
50 /* Info dialogs currently open.
51  * Each dialog contains a referenced pointer to its Individual */
52 static GList *information_dialogs = NULL;
53
54 static void individual_information_dialog_set_individual (
55     EmpathyIndividualInformationDialog *dialog,
56     FolksIndividual *individual);
57
58 G_DEFINE_TYPE (EmpathyIndividualInformationDialog,
59     empathy_individual_information_dialog, GTK_TYPE_DIALOG);
60
61 static void
62 individual_dialogs_response_cb (GtkDialog *dialog,
63     gint response,
64     GList **dialogs)
65 {
66   *dialogs = g_list_remove (*dialogs, dialog);
67   gtk_widget_destroy (GTK_WIDGET (dialog));
68 }
69
70 static gint
71 individual_dialogs_find (GObject *object,
72     FolksIndividual *individual)
73 {
74   EmpathyIndividualInformationDialogPriv *priv = GET_PRIV (object);
75
76   return individual != priv->individual;
77 }
78
79 void
80 empathy_individual_information_dialog_show (FolksIndividual *individual,
81     GtkWindow *parent)
82 {
83   GtkWidget *dialog;
84   GList *l;
85
86   g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual));
87   g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
88
89   l = g_list_find_custom (information_dialogs, individual,
90       (GCompareFunc) individual_dialogs_find);
91
92   if (l != NULL)
93     {
94       gtk_window_present (GTK_WINDOW (l->data));
95       return;
96     }
97
98   /* Create dialog */
99   dialog = g_object_new (EMPATHY_TYPE_INDIVIDUAL_INFORMATION_DIALOG,
100       "individual", individual,
101       NULL);
102
103   information_dialogs = g_list_prepend (information_dialogs, dialog);
104   gtk_widget_show (dialog);
105 }
106
107 static void
108 individual_removed_cb (FolksIndividual *individual,
109     FolksIndividual *replacement_individual,
110     EmpathyIndividualInformationDialog *self)
111 {
112   individual_information_dialog_set_individual (self,
113       replacement_individual);
114
115   /* Destroy the dialogue */
116   if (replacement_individual == NULL)
117     {
118       individual_dialogs_response_cb (GTK_DIALOG (self),
119           GTK_RESPONSE_DELETE_EVENT, &information_dialogs);
120     }
121 }
122
123 static void
124 set_label_visibility (EmpathyIndividualInformationDialog *dialog)
125 {
126   EmpathyIndividualInformationDialogPriv *priv = GET_PRIV (dialog);
127   guint num_personas = 0;
128
129   /* Count how many Telepathy personas we have, to see whether we can
130    * unlink */
131   if (priv->individual != NULL)
132     {
133       GeeSet *personas;
134       GeeIterator *iter;
135
136       personas = folks_individual_get_personas (priv->individual);
137       iter = gee_iterable_iterator (GEE_ITERABLE (personas));
138       while (gee_iterator_next (iter))
139         {
140           FolksPersona *persona = gee_iterator_get (iter);
141           if (empathy_folks_persona_is_interesting (persona))
142             num_personas++;
143
144           g_clear_object (&persona);
145         }
146       g_clear_object (&iter);
147     }
148
149   /* Only make the label visible if we have enough personas */
150   gtk_widget_set_visible (priv->label, (num_personas > 1) ? TRUE : FALSE);
151 }
152
153 static void
154 individual_information_dialog_set_individual (
155     EmpathyIndividualInformationDialog *dialog,
156     FolksIndividual *individual)
157 {
158   EmpathyIndividualInformationDialogPriv *priv;
159
160   g_return_if_fail (EMPATHY_INDIVIDUAL_INFORMATION_DIALOG (dialog));
161   g_return_if_fail (individual == NULL || FOLKS_IS_INDIVIDUAL (individual));
162
163   priv = GET_PRIV (dialog);
164
165   /* Remove the old Individual */
166   if (priv->individual != NULL)
167     {
168       g_signal_handlers_disconnect_by_func (priv->individual,
169           (GCallback) individual_removed_cb, dialog);
170     }
171
172   tp_clear_object (&priv->individual);
173
174   /* Add the new Individual */
175   priv->individual = individual;
176
177   if (individual != NULL)
178     {
179       g_object_ref (individual);
180       g_signal_connect (individual, "removed",
181           (GCallback) individual_removed_cb, dialog);
182
183       /* Update the UI */
184       gtk_window_set_title (GTK_WINDOW (dialog),
185           folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual)));
186       empathy_individual_widget_set_individual (
187           EMPATHY_INDIVIDUAL_WIDGET (priv->individual_widget), individual);
188       set_label_visibility (dialog);
189     }
190 }
191
192 static void
193 individual_information_dialog_get_property (GObject *object,
194     guint param_id,
195     GValue *value,
196     GParamSpec *pspec)
197 {
198   EmpathyIndividualInformationDialogPriv *priv = GET_PRIV (object);
199
200   switch (param_id) {
201   case PROP_INDIVIDUAL:
202     g_value_set_object (value, priv->individual);
203     break;
204   default:
205     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
206     break;
207   };
208 }
209
210 static void
211 individual_information_dialog_set_property (GObject *object,
212   guint param_id,
213   const GValue *value,
214   GParamSpec   *pspec)
215 {
216   EmpathyIndividualInformationDialog *dialog =
217     EMPATHY_INDIVIDUAL_INFORMATION_DIALOG (object);
218
219   switch (param_id) {
220   case PROP_INDIVIDUAL:
221     individual_information_dialog_set_individual (dialog,
222         FOLKS_INDIVIDUAL (g_value_get_object (value)));
223     break;
224   default:
225     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
226     break;
227   };
228 }
229
230 static void
231 individual_information_dialog_dispose (GObject *object)
232 {
233   individual_information_dialog_set_individual (
234       EMPATHY_INDIVIDUAL_INFORMATION_DIALOG (object), NULL);
235
236   G_OBJECT_CLASS (
237       empathy_individual_information_dialog_parent_class)->dispose (object);
238 }
239
240 static void
241 empathy_individual_information_dialog_class_init (
242     EmpathyIndividualInformationDialogClass *klass)
243 {
244   GObjectClass *object_class = G_OBJECT_CLASS (klass);
245
246   object_class->dispose = individual_information_dialog_dispose;
247   object_class->get_property = individual_information_dialog_get_property;
248   object_class->set_property = individual_information_dialog_set_property;
249
250   g_object_class_install_property (object_class,
251       PROP_INDIVIDUAL,
252       g_param_spec_object ("individual",
253           "Folks Individual",
254           "Folks Individual to base the dialog upon",
255           FOLKS_TYPE_INDIVIDUAL,
256           G_PARAM_CONSTRUCT |
257           G_PARAM_READWRITE |
258           G_PARAM_STATIC_STRINGS));
259
260   g_type_class_add_private (object_class,
261       sizeof (EmpathyIndividualInformationDialogPriv));
262 }
263
264 static void
265 empathy_individual_information_dialog_init (
266     EmpathyIndividualInformationDialog *dialog)
267 {
268   GtkWidget *button;
269   GtkBox *content_area;
270   gchar *label_string;
271   EmpathyIndividualInformationDialogPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (
272       dialog, EMPATHY_TYPE_INDIVIDUAL_INFORMATION_DIALOG,
273       EmpathyIndividualInformationDialogPriv);
274
275   dialog->priv = priv;
276   priv->individual = NULL;
277
278   gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
279
280   content_area = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog)));
281
282   /* Translators: the heading at the top of the Information dialogue */
283   label_string = g_strdup_printf ("<b>%s</b>", _("Linked Contacts"));
284   priv->label = gtk_label_new (NULL);
285   gtk_label_set_markup (GTK_LABEL (priv->label), label_string);
286   g_free (label_string);
287
288   gtk_misc_set_alignment (GTK_MISC (priv->label), 0.0, 0.5);
289   gtk_misc_set_padding (GTK_MISC (priv->label), 6, 6);
290   gtk_box_pack_start (content_area, priv->label, FALSE, TRUE, 0);
291   gtk_widget_show (priv->label);
292
293   /* Individual widget */
294   priv->individual_widget = empathy_individual_widget_new (priv->individual,
295       EMPATHY_INDIVIDUAL_WIDGET_SHOW_LOCATION |
296       EMPATHY_INDIVIDUAL_WIDGET_SHOW_DETAILS |
297       EMPATHY_INDIVIDUAL_WIDGET_SHOW_PERSONAS);
298   gtk_container_set_border_width (GTK_CONTAINER (priv->individual_widget), 6);
299   gtk_box_pack_start (content_area, priv->individual_widget, TRUE, TRUE, 0);
300   gtk_widget_show (priv->individual_widget);
301
302   /* Close button */
303   button = gtk_button_new_with_label (GTK_STOCK_CLOSE);
304   gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
305   gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
306       GTK_RESPONSE_CLOSE);
307   gtk_widget_set_can_default (button, TRUE);
308   gtk_window_set_default (GTK_WINDOW (dialog), button);
309   gtk_widget_show (button);
310
311   g_signal_connect (dialog, "response",
312       G_CALLBACK (individual_dialogs_response_cb), &information_dialogs);
313 }
314
315 static void
316 show_gnome_contacts_error_dialog (void)
317 {
318   GtkWidget *dialog;
319
320   dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
321       GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
322       _("gnome-contacts not installed"));
323
324   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
325       _("Please install gnome-contacts to access contacts details."));
326
327   g_signal_connect_swapped (dialog, "response",
328           G_CALLBACK (gtk_widget_destroy), dialog);
329
330   gtk_widget_show (dialog);
331 }
332
333 static void
334 start_gnome_contacts (FolksIndividual *individual,
335     gboolean try_installing);
336
337 static void
338 install_gnome_contacts_cb (GObject *source,
339     GAsyncResult *result,
340     gpointer user_data)
341 {
342   FolksIndividual *individual = user_data;
343   GError *error = NULL;
344
345   if (!empathy_pkg_kit_install_packages_finish (result, &error))
346     {
347       DEBUG ("Failed to install gnome-contacts: %s", error->message);
348       g_error_free (error);
349
350       show_gnome_contacts_error_dialog ();
351       goto out;
352     }
353
354   DEBUG ("gnome-contacts installed");
355
356   start_gnome_contacts (individual, FALSE);
357
358 out:
359   g_object_unref (individual);
360 }
361
362 static void
363 start_gnome_contacts (FolksIndividual *individual,
364     gboolean try_installing)
365 {
366   gchar *args;
367   GError *error = NULL;
368
369   g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual));
370
371   args = g_strdup_printf ("-i %s", folks_individual_get_id (individual));
372
373   /* First try the old desktop name */
374   if (empathy_launch_external_app ("gnome-contacts.desktop", args, NULL))
375     goto out;
376
377   if (!empathy_launch_external_app ("org.gnome.Contacts.desktop", args, &error))
378     {
379       if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
380         {
381           if (try_installing)
382             {
383               const gchar *packages[] = { "gnome-contacts", NULL };
384
385               DEBUG ("gnome-contacts not installed; try to install it");
386
387               empathy_pkg_kit_install_packages_async (0, packages, NULL,
388                   NULL, install_gnome_contacts_cb, g_object_ref (individual));
389             }
390           else
391             {
392               show_gnome_contacts_error_dialog ();
393             }
394         }
395     }
396
397 out:
398   g_free (args);
399 }
400
401 /* Use gnome-contacts to display @individual or fallback to
402  * EmpathyIndividualInformationDialog if user is not not in Folks.
403  */
404 void
405 empathy_display_individual_info (FolksIndividual *individual)
406 {
407   EmpathyIndividualManager *mgr;
408
409   mgr = empathy_individual_manager_dup_singleton ();
410
411   /* Only use gnome-contacts if that's a 'real' individual we got from
412    * Folks (and so the individual manager knows about it). If not that's a
413    * MUC contact and we use the simple dialog. */
414   if (empathy_individual_manager_lookup_member (mgr,
415         folks_individual_get_id (individual)) != NULL)
416     {
417       start_gnome_contacts (individual, TRUE);
418     }
419   else
420     {
421       empathy_individual_information_dialog_show (individual, NULL);
422     }
423
424   g_object_unref (mgr);
425 }