libempathy-gtk/empathy-new-message-dialog.c

   1 /*
   2  * Copyright (C) 2007-2008 Collabora Ltd.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library 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  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  * Authors: Xavier Claessens <xclaesse@gmail.com>
  19  */
  20
  21 #include <config.h>
  22
  23 #include <string.h>
  24 #include <stdlib.h>
  25
  26 #include <gtk/gtk.h>
  27 #include <glib/gi18n-lib.h>
  28
  29 #include <telepathy-glib/interfaces.h>
  30
  31 #include <libempathy/empathy-tp-contact-factory.h>
  32 #include <libempathy/empathy-contact-manager.h>
  33 #include <libempathy/empathy-request-util.h>
  34 #include <libempathy/empathy-utils.h>
  35
  36 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
  37 #include <libempathy/empathy-debug.h>
  38
  39 #include <libempathy-gtk/empathy-contact-chooser.h>
  40 #include <libempathy-gtk/empathy-ui-utils.h>
  41 #include <libempathy-gtk/empathy-images.h>
  42
  43 #include "empathy-new-message-dialog.h"
  44 #include "empathy-account-chooser.h"
  45
  46 static EmpathyNewMessageDialog *dialog_singleton = NULL;
  47
  48 G_DEFINE_TYPE(EmpathyNewMessageDialog, empathy_new_message_dialog,
  49     GTK_TYPE_DIALOG)
  50
  51 struct _EmpathyNewMessageDialogPriv {
  52   GtkWidget *chooser;
  53   GtkWidget *button_chat;
  54   GtkWidget *button_sms;
  55 };
  56
  57 /**
  58  * SECTION:empathy-new-message-dialog
  59  * @title: EmpathyNewMessageDialog
  60  * @short_description: A dialog to show a new message
  61  * @include: libempathy-gtk/empathy-new-message-dialog.h
  62  *
  63  * #EmpathyNewMessageDialog is a dialog which allows a text chat
  64  * to be started with any contact on any enabled account.
  65  */
  66
  67 enum
  68 {
  69   EMP_NEW_MESSAGE_TEXT,
  70   EMP_NEW_MESSAGE_SMS,
  71 };
  72
  73 static const gchar *
  74 get_error_display_message (GError *error)
  75 {
  76   if (error->domain != TP_ERROR)
  77     goto out;
  78
  79   switch (error->code)
  80     {
  81       case TP_ERROR_NETWORK_ERROR:
  82         return _("Network error");
  83       case TP_ERROR_OFFLINE:
  84         return _("The contact is offline");
  85       case TP_ERROR_INVALID_HANDLE:
  86         return _("The specified contact is either invalid or unknown");
  87       case TP_ERROR_NOT_CAPABLE:
  88         return _("The contact does not support this kind of conversation");
  89       case TP_ERROR_NOT_IMPLEMENTED:
  90         return _("The requested functionality is not implemented "
  91                  "for this protocol");
  92       case TP_ERROR_INVALID_ARGUMENT:
  93         /* Not very user friendly to say 'invalid arguments' */
  94         break;
  95       case TP_ERROR_NOT_AVAILABLE:
  96         return _("Could not start a conversation with the given contact");
  97       case TP_ERROR_CHANNEL_BANNED:
  98         return _("You are banned from this channel");
  99       case TP_ERROR_CHANNEL_FULL:
 100         return _("This channel is full");
 101       case TP_ERROR_CHANNEL_INVITE_ONLY:
 102         return _("You must be invited to join this channel");
 103       case TP_ERROR_DISCONNECTED:
 104         return _("Can't proceed while disconnected");
 105       case TP_ERROR_PERMISSION_DENIED:
 106         return _("Permission denied");
 107       default:
 108         DEBUG ("Unhandled error code: %d", error->code);
 109     }
 110
 111 out:
 112   return _("There was an error starting the conversation");
 113 }
 114
 115 static void
 116 show_chat_error (GError *error,
 117     GtkWindow *parent)
 118 {
 119   GtkWidget *dialog;
 120
 121   dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL,
 122       GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
 123       "%s",
 124       get_error_display_message (error));
 125
 126   g_signal_connect_swapped (dialog, "response",
 127       G_CALLBACK (gtk_widget_destroy),
 128       dialog);
 129
 130   gtk_widget_show (dialog);
 131 }
 132
 133 static void
 134 ensure_text_channel_cb (GObject *source,
 135     GAsyncResult *result,
 136     gpointer user_data)
 137 {
 138   GError *error = NULL;
 139
 140   if (!tp_account_channel_request_ensure_channel_finish (
 141         TP_ACCOUNT_CHANNEL_REQUEST (source), result, &error))
 142     {
 143       DEBUG ("Failed to ensure text channel: %s", error->message);
 144       show_chat_error (error, user_data);
 145       g_error_free (error);
 146     }
 147 }
 148
 149 static void
 150 empathy_new_message_dialog_response (GtkDialog *dialog,
 151     int response_id)
 152 {
 153   EmpathyNewMessageDialog *self = (EmpathyNewMessageDialog *) dialog;
 154   FolksIndividual *individual = NULL;
 155   EmpathyContact *contact = NULL;
 156
 157   if (response_id < EMP_NEW_MESSAGE_TEXT)
 158     goto out;
 159
 160   individual = empathy_contact_chooser_dup_selected (
 161       EMPATHY_CONTACT_CHOOSER (self->priv->chooser));
 162   if (individual == NULL)
 163     goto out;
 164
 165   switch (response_id)
 166     {
 167       case EMP_NEW_MESSAGE_TEXT:
 168         contact = empathy_contact_dup_best_for_action (individual,
 169             EMPATHY_ACTION_CHAT);
 170         g_return_if_fail (contact != NULL);
 171
 172         empathy_chat_with_contact_id (empathy_contact_get_account (contact),
 173             empathy_contact_get_id (contact),
 174             empathy_get_current_action_time (),
 175             ensure_text_channel_cb,
 176             gtk_widget_get_parent_window (GTK_WIDGET (dialog)));
 177         break;
 178
 179       case EMP_NEW_MESSAGE_SMS:
 180         contact = empathy_contact_dup_best_for_action (individual,
 181             EMPATHY_ACTION_SMS);
 182         g_return_if_fail (contact != NULL);
 183
 184         empathy_sms_contact_id (empathy_contact_get_account (contact),
 185             empathy_contact_get_id (contact),
 186             empathy_get_current_action_time (),
 187             ensure_text_channel_cb,
 188             gtk_widget_get_parent_window (GTK_WIDGET (dialog)));
 189         break;
 190
 191       default:
 192         g_warn_if_reached ();
 193     }
 194
 195 out:
 196   tp_clear_object (&individual);
 197   tp_clear_object (&contact);
 198   gtk_widget_destroy (GTK_WIDGET (dialog));
 199 }
 200
 201 static GObject *
 202 empathy_new_message_dialog_constructor (GType type,
 203     guint n_props,
 204     GObjectConstructParam *props)
 205 {
 206   GObject *retval;
 207
 208   if (dialog_singleton)
 209     {
 210       retval = G_OBJECT (dialog_singleton);
 211       g_object_ref (retval);
 212     }
 213   else
 214     {
 215       retval = G_OBJECT_CLASS (
 216       empathy_new_message_dialog_parent_class)->constructor (type,
 217         n_props, props);
 218
 219       dialog_singleton = EMPATHY_NEW_MESSAGE_DIALOG (retval);
 220       g_object_add_weak_pointer (retval, (gpointer) &dialog_singleton);
 221     }
 222
 223   return retval;
 224 }
 225
 226 static gboolean
 227 individual_supports_action (FolksIndividual *individual,
 228     EmpathyActionType action)
 229 {
 230   EmpathyContact *contact;
 231
 232   contact = empathy_contact_dup_best_for_action (individual, action);
 233   if (contact == NULL)
 234     return FALSE;
 235
 236   g_object_unref (contact);
 237   return TRUE;
 238 }
 239
 240 static gboolean
 241 filter_individual (EmpathyContactChooser *chooser,
 242     FolksIndividual *individual,
 243     gboolean is_online,
 244     gboolean searching,
 245     gpointer user_data)
 246 {
 247   return individual_supports_action (individual, EMPATHY_ACTION_CHAT) ||
 248     individual_supports_action (individual, EMPATHY_ACTION_SMS);
 249 }
 250
 251 static void
 252 selection_changed_cb (GtkWidget *chooser,
 253     FolksIndividual *selected,
 254     EmpathyNewMessageDialog *self)
 255 {
 256   gboolean can_chat, can_sms;
 257
 258   if (selected == NULL)
 259     {
 260       can_chat = can_sms = FALSE;
 261     }
 262   else
 263     {
 264       can_chat = individual_supports_action (selected, EMPATHY_ACTION_CHAT);
 265       can_sms = individual_supports_action (selected, EMPATHY_ACTION_SMS);
 266     }
 267
 268   gtk_widget_set_sensitive (self->priv->button_chat, can_chat);
 269   gtk_widget_set_sensitive (self->priv->button_sms, can_sms);
 270 }
 271
 272 static void
 273 selection_activate_cb (GtkWidget *chooser,
 274     EmpathyNewMessageDialog *self)
 275 {
 276   gtk_dialog_response (GTK_DIALOG (self), EMP_NEW_MESSAGE_TEXT);
 277 }
 278
 279 static void
 280 empathy_new_message_dialog_init (EmpathyNewMessageDialog *self)
 281 {
 282   GtkWidget *label;
 283   GtkWidget *image;
 284   GtkWidget *content;
 285
 286   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 287       EMPATHY_TYPE_NEW_MESSAGE_DIALOG, EmpathyNewMessageDialogPriv);
 288
 289   content = gtk_dialog_get_content_area (GTK_DIALOG (self));
 290
 291   label = gtk_label_new (_("Enter a contact identifier or phone number:"));
 292   gtk_box_pack_start (GTK_BOX (content), label, FALSE, FALSE, 0);
 293   gtk_widget_show (label);
 294
 295   /* contact chooser */
 296   self->priv->chooser = empathy_contact_chooser_new ();
 297
 298   empathy_contact_chooser_set_filter_func (
 299       EMPATHY_CONTACT_CHOOSER (self->priv->chooser), filter_individual, self);
 300
 301   gtk_box_pack_start (GTK_BOX (content), self->priv->chooser, TRUE, TRUE, 6);
 302   gtk_widget_show (self->priv->chooser);
 303
 304   g_signal_connect (self->priv->chooser, "selection-changed",
 305       G_CALLBACK (selection_changed_cb), self);
 306   g_signal_connect (self->priv->chooser, "activate",
 307       G_CALLBACK (selection_activate_cb), self);
 308
 309   /* close button */
 310   gtk_dialog_add_buttons (GTK_DIALOG (self), GTK_STOCK_CLOSE, NULL);
 311
 312   /* add SMS button */
 313   self->priv->button_sms = gtk_button_new_with_mnemonic (_("_SMS"));
 314   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_SMS,
 315       GTK_ICON_SIZE_BUTTON);
 316   gtk_button_set_image (GTK_BUTTON (self->priv->button_sms), image);
 317
 318   /* add chat button */
 319   self->priv->button_chat = gtk_button_new_with_mnemonic (_("_Chat"));
 320   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_NEW_MESSAGE,
 321       GTK_ICON_SIZE_BUTTON);
 322   gtk_button_set_image (GTK_BUTTON (self->priv->button_chat), image);
 323
 324   gtk_dialog_add_action_widget (GTK_DIALOG (self), self->priv->button_chat,
 325       EMP_NEW_MESSAGE_TEXT);
 326   gtk_widget_show (self->priv->button_chat);
 327
 328   gtk_dialog_add_action_widget (GTK_DIALOG (self), self->priv->button_sms,
 329       EMP_NEW_MESSAGE_SMS);
 330   gtk_widget_show (self->priv->button_sms);
 331
 332   /* Tweak the dialog */
 333   gtk_window_set_title (GTK_WINDOW (self), _("New Conversation"));
 334   gtk_window_set_role (GTK_WINDOW (self), "new_message");
 335
 336   /* Set a default height so a few contacts are displayed */
 337   gtk_window_set_default_size (GTK_WINDOW (self), -1, 400);
 338
 339   gtk_widget_set_sensitive (self->priv->button_chat, FALSE);
 340   gtk_widget_set_sensitive (self->priv->button_sms, FALSE);
 341 }
 342
 343 static void
 344 empathy_new_message_dialog_class_init (
 345   EmpathyNewMessageDialogClass *class)
 346 {
 347   GObjectClass *object_class = G_OBJECT_CLASS (class);
 348   GtkDialogClass *dialog_class = GTK_DIALOG_CLASS (class);
 349
 350   object_class->constructor = empathy_new_message_dialog_constructor;
 351
 352   dialog_class->response = empathy_new_message_dialog_response;
 353
 354   g_type_class_add_private (class, sizeof (EmpathyNewMessageDialogPriv));
 355 }
 356
 357 /**
 358  * empathy_new_message_dialog_new:
 359  * @parent: parent #GtkWindow of the dialog
 360  *
 361  * Create a new #EmpathyNewMessageDialog it.
 362  *
 363  * Return value: the new #EmpathyNewMessageDialog
 364  */
 365 GtkWidget *
 366 empathy_new_message_dialog_show (GtkWindow *parent)
 367 {
 368   GtkWidget *dialog;
 369
 370   dialog = g_object_new (EMPATHY_TYPE_NEW_MESSAGE_DIALOG, NULL);
 371
 372   if (parent)
 373     {
 374       gtk_window_set_transient_for (GTK_WINDOW (dialog),
 375           GTK_WINDOW (parent));
 376     }
 377
 378   gtk_widget_show (dialog);
 379   return dialog;
 380 }