← Back to branch summary

~ubuntu-branches/ubuntu/precise/nautilus-sendto-universe/precise

« back to all changes in this revision

Viewing changes to src/plugins/empathy/empathy.c

  • Committer: Bazaar Package Importer
  • Author(s): Onkar Shinde
  • Date: 2009-07-30 23:31:20 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090730233120-ut3baoo6lde6q9gk
Tags: 1.1.6-0ubuntu1
https://launchpad.net/bugs/377192
* New upstream release. (LP: #377192)
* debian/control
  - Remove libglade2-dev build dependency.
  - Bump version of libgtk2.0-dev build dependency to 2.12.
  - Remove empathy related build dependencies.
  - Update description to remove empathy references.
* debian/nautilus-sendto-universe.install
  - Remove empathy plugin.
* debian/patches/10_fix_empathy_2.26.patch
  - Remove. Not needed anymore.
* debian/README.Debian.
  - Update to remove empathy references.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/empathy/empathy.c
1
1
/*
2
 
 * Copyright (C) 2008 Collabora Ltd.
 
2
 * Copyright (C) 2008, 2009 Collabora Ltd.
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or
5
5
 * modify it under the terms of the GNU General Public License as
16
16
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17
17
 * Boston, MA 02110-1301  USA.
18
18
 *
19
 
 * Author: Jonny Lamb <jonny.lamb@collabora.co.uk>
 
19
 * Authors: Jonny Lamb <jonny.lamb@collabora.co.uk>
 
20
 *          Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
20
21
 */
21
22
 
22
23
#include "config.h"
26
27
#include <gtk/gtk.h>
27
28
#include <gio/gio.h>
28
29
 
 
30
#include <telepathy-glib/enums.h>
 
31
 
 
32
#include <libempathy/empathy-contact.h>
29
33
#include <libempathy/empathy-debug.h>
30
34
#include <libempathy/empathy-contact-manager.h>
31
 
#include <libempathy/empathy-dispatcher.h>
 
35
#include <libempathy/empathy-ft-factory.h>
 
36
#include <libempathy/empathy-ft-handler.h>
 
37
#include <libempathy/empathy-tp-file.h>
32
38
#include <libempathy/empathy-utils.h>
33
39
 
34
 
#include <libempathy-gtk/empathy-contact-list-store.h>
 
40
#include <libempathy-gtk/empathy-contact-selector.h>
 
41
#include <libempathy-gtk/empathy-ui-utils.h>
35
42
 
36
43
#include "nautilus-sendto-plugin.h"
37
44
 
38
 
static EmpathyContactManager *manager = NULL;
39
45
static MissionControl *mc = NULL;
 
46
static EmpathyFTFactory *factory = NULL;
 
47
static guint transfers = 0;
40
48
 
41
49
static gboolean destroy (NstPlugin *plugin);
42
50
 
48
56
 
49
57
  g_print ("Init %s plugin\n", plugin->info->id);
50
58
 
51
 
  empathy_debug_set_flags (g_getenv ("EMPATHY_DEBUG"));
52
 
 
53
 
  mc = empathy_mission_control_new ();
 
59
  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 
60
  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 
61
 
 
62
  empathy_gtk_init ();
 
63
 
 
64
  mc = empathy_mission_control_dup_singleton ();
54
65
  accounts = mission_control_get_online_connections (mc, FALSE);
55
66
 
56
67
  if (g_slist_length (accounts) == 0)
70
81
static GtkWidget *
71
82
get_contacts_widget (NstPlugin *plugin)
72
83
{
73
 
  EmpathyContactListStore *store;
74
 
  GtkWidget *combo;
75
 
  GtkCellRenderer *renderer;
76
 
 
77
 
  /* TODO: Replace all this with EmpathyContactSelector once it's fixed up and
78
 
   * merged into libempathy-gtk. */
79
 
  manager = empathy_contact_manager_new ();
80
 
  store = empathy_contact_list_store_new (EMPATHY_CONTACT_LIST (manager));
81
 
 
82
 
  empathy_contact_list_store_set_is_compact (store, TRUE);
83
 
  empathy_contact_list_store_set_show_groups (store, FALSE);
84
 
 
85
 
  combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
86
 
 
87
 
  renderer = gtk_cell_renderer_text_new ();
88
 
 
89
 
  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
90
 
  gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo),
91
 
      renderer, "text", EMPATHY_CONTACT_LIST_STORE_COL_NAME);
92
 
 
93
 
  return combo;
 
84
  EmpathyContactManager *manager;
 
85
  GtkWidget *selector;
 
86
 
 
87
  manager = empathy_contact_manager_dup_singleton ();
 
88
  selector = empathy_contact_selector_new (EMPATHY_CONTACT_LIST (manager));
 
89
 
 
90
  empathy_contact_selector_set_visible (EMPATHY_CONTACT_SELECTOR (selector),
 
91
      (EmpathyContactSelectorFilterFunc) empathy_contact_can_send_files, NULL);
 
92
 
 
93
  g_object_unref (manager);
 
94
 
 
95
  return selector;
94
96
}
95
97
 
96
 
static gboolean
97
 
get_selected_contact (GtkWidget *contact_widget,
98
 
                      EmpathyContact **contact)
 
98
static EmpathyContact *
 
99
get_selected_contact (GtkWidget *contact_widget)
99
100
{
 
101
  EmpathyContact *contact;
100
102
  GtkTreeModel *model;
101
103
  GtkTreeIter iter;
102
104
 
103
105
  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (contact_widget), &iter))
104
 
    return FALSE;
 
106
    return NULL;
105
107
 
106
108
  model = gtk_combo_box_get_model (GTK_COMBO_BOX (contact_widget));
107
109
  gtk_tree_model_get (model, &iter,
108
 
      EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, -1);
109
 
 
110
 
  if (*contact == NULL)
111
 
    return FALSE;
112
 
 
113
 
  return TRUE;
 
110
      EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact, -1);
 
111
 
 
112
  return contact;
114
113
}
115
114
 
116
115
static gboolean
119
118
                      gchar **error)
120
119
{
121
120
  EmpathyContact *contact = NULL;
122
 
 
123
 
  if (!get_selected_contact (contact_widget, &contact))
 
121
  gboolean ret = TRUE;
 
122
 
 
123
  contact = get_selected_contact (contact_widget);
 
124
 
 
125
  if (!contact)
124
126
    return FALSE;
125
127
 
126
128
  if (!empathy_contact_can_send_files (contact))
127
129
    {
128
130
      *error = g_strdup (_("The contact selected cannot receive files."));
129
 
      return FALSE;
 
131
      ret = FALSE;
130
132
    }
131
133
 
132
 
  if (!empathy_contact_is_online (contact))
 
134
  if (ret && !empathy_contact_is_online (contact))
133
135
    {
134
136
      *error = g_strdup (_("The contact selected is offline."));
135
 
      return FALSE;
 
137
      ret = FALSE;
136
138
    }
137
139
 
138
140
  g_object_unref (contact);
139
141
 
140
 
  return TRUE;
 
142
  return ret;
 
143
}
 
144
 
 
145
static void
 
146
quit (void)
 
147
{
 
148
  if (--transfers > 0)
 
149
    return;
 
150
 
 
151
  destroy (NULL);
 
152
  gtk_main_quit ();
 
153
}
 
154
 
 
155
static void
 
156
transfer_done_cb (EmpathyFTHandler *handler,
 
157
                  EmpathyTpFile *tp_file,
 
158
                  NstPlugin *plugin)
 
159
{
 
160
  quit ();  
 
161
}
 
162
 
 
163
static void
 
164
transfer_error_cb (EmpathyFTHandler *handler,
 
165
                   GError *error,
 
166
                   NstPlugin *plugin)
 
167
{
 
168
  quit ();
 
169
}
 
170
 
 
171
static void
 
172
error_dialog_cb (GtkDialog *dialog,
 
173
                 gint arg,
 
174
                 gpointer user_data)
 
175
{
 
176
  gtk_widget_destroy (GTK_WIDGET (dialog));
 
177
  quit ();
 
178
}
 
179
 
 
180
static void
 
181
handler_ready_cb (EmpathyFTFactory *factory,
 
182
                  EmpathyFTHandler *handler,
 
183
                  GError *error,
 
184
                  NstPlugin *plugin)
 
185
{
 
186
  g_print ("handler ready!, error %p", error);
 
187
 
 
188
  if (error != NULL)
 
189
    {
 
190
      GtkWidget *dialog;
 
191
      dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR,
 
192
          GTK_BUTTONS_CLOSE, "%s",
 
193
          error->message ? error->message : _("No error message"));
 
194
 
 
195
      g_signal_connect (dialog, "response", G_CALLBACK (error_dialog_cb), NULL);
 
196
      gtk_widget_show (dialog);
 
197
    }
 
198
  else
 
199
    {
 
200
      g_signal_connect (handler, "transfer-done",
 
201
          G_CALLBACK (transfer_done_cb), plugin);
 
202
      g_signal_connect (handler, "transfer-error",
 
203
          G_CALLBACK (transfer_error_cb), plugin);
 
204
 
 
205
      empathy_ft_handler_start_transfer (handler);
 
206
    }
141
207
}
142
208
 
143
209
static gboolean
145
211
            GtkWidget *contact_widget,
146
212
            GList *file_list)
147
213
{
148
 
  EmpathyContact *contact = NULL;
 
214
  EmpathyContact *contact;
149
215
  GList *l;
150
216
 
151
 
  if (!get_selected_contact (contact_widget, &contact))
 
217
  contact = get_selected_contact (contact_widget);
 
218
 
 
219
  if (!contact)
152
220
    return FALSE;
153
221
 
 
222
  factory = empathy_ft_factory_dup_singleton ();
 
223
 
 
224
  g_signal_connect (factory, "new-ft-handler",
 
225
      G_CALLBACK (handler_ready_cb), plugin);
 
226
 
154
227
  for (l = file_list; l; l = l->next)
155
228
    {
156
229
      gchar *path = l->data;
157
230
      GFile *file;
158
231
 
159
232
      file = g_file_new_for_uri (path);
160
 
      empathy_dispatcher_send_file (contact, file);
 
233
 
 
234
      ++transfers;
 
235
 
 
236
      empathy_ft_factory_new_transfer_outgoing (factory,
 
237
          contact, file);
161
238
 
162
239
      g_object_unref (file);
163
 
      g_free (path);
164
240
    }
165
241
 
166
242
  g_object_unref (contact);
167
243
 
168
 
  return TRUE;
 
244
  if (transfers == 0)
 
245
    {
 
246
      destroy (NULL);
 
247
      return TRUE;
 
248
    }
 
249
 
 
250
  return FALSE;
169
251
}
170
252
 
171
253
static gboolean
172
254
destroy (NstPlugin *plugin)
173
255
{
174
 
  if (manager)
175
 
    g_object_unref (manager);
176
 
 
177
256
  if (mc)
178
257
    g_object_unref (mc);
179
258
 
 
259
  if (factory)
 
260
    g_object_unref (factory);
 
261
 
180
262
  return TRUE;
181
263
}
182
264