← Back to branch summary

~ubuntu-branches/ubuntu/natty/empathy/natty-updates

« back to all changes in this revision

Viewing changes to libempathy/empathy-irc-network.c

  • Committer: Bazaar Package Importer
  • Author(s): Sjoerd Simons
  • Date: 2008-03-10 16:39:07 UTC
  • mfrom: (1.1.13 upstream)
  • Revision ID: james.westby@ubuntu.com-20080310163907-tv41g2zmf0qqgi85
Tags: 0.22.0-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
libempathy/empathy-irc-network.c
 
1
/*
 
2
 * Copyright (C) 2007 Guillaume Desmottes
 
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., 59 Temple Place - Suite 330,
 
17
 * Boston, MA 02111-1307, USA.
 
18
 *
 
19
 * Authors: Guillaume Desmottes <gdesmott@gnome.org>
 
20
 */
 
21
 
 
22
#include <config.h>
 
23
#include <string.h>
 
24
#include <stdlib.h>
 
25
#include <glib.h>
 
26
#include <glib/gi18n.h>
 
27
 
 
28
#include <telepathy-glib/util.h>
 
29
 
 
30
#include "empathy-marshal.h"
 
31
#include "empathy-irc-network.h"
 
32
 
 
33
G_DEFINE_TYPE (EmpathyIrcNetwork, empathy_irc_network, G_TYPE_OBJECT);
 
34
 
 
35
/* properties */
 
36
enum
 
37
{
 
38
  PROP_NAME = 1,
 
39
  PROP_CHARSET,
 
40
  LAST_PROPERTY
 
41
};
 
42
 
 
43
/* signals */
 
44
enum
 
45
{
 
46
  MODIFIED,
 
47
  LAST_SIGNAL
 
48
};
 
49
 
 
50
static guint signals[LAST_SIGNAL] = {0};
 
51
 
 
52
typedef struct _EmpathyIrcNetworkPrivate EmpathyIrcNetworkPrivate;
 
53
 
 
54
struct _EmpathyIrcNetworkPrivate
 
55
{
 
56
  gchar *name;
 
57
  gchar *charset;
 
58
  GSList *servers;
 
59
};
 
60
 
 
61
#define EMPATHY_IRC_NETWORK_GET_PRIVATE(obj)\
 
62
    ((EmpathyIrcNetworkPrivate *) obj->priv)
 
63
 
 
64
static void
 
65
server_modified_cb (EmpathyIrcServer *server,
 
66
                    EmpathyIrcNetwork *self)
 
67
{
 
68
  g_signal_emit (self, signals[MODIFIED], 0);
 
69
}
 
70
 
 
71
static void
 
72
empathy_irc_network_get_property (GObject *object,
 
73
                                  guint property_id,
 
74
                                  GValue *value,
 
75
                                  GParamSpec *pspec)
 
76
{
 
77
  EmpathyIrcNetwork *self = EMPATHY_IRC_NETWORK (object);
 
78
  EmpathyIrcNetworkPrivate *priv = EMPATHY_IRC_NETWORK_GET_PRIVATE (self);
 
79
 
 
80
  switch (property_id)
 
81
    {
 
82
      case PROP_NAME:
 
83
        g_value_set_string (value, priv->name);
 
84
        break;
 
85
      case PROP_CHARSET:
 
86
        g_value_set_string (value, priv->charset);
 
87
        break;
 
88
      default:
 
89
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
90
        break;
 
91
    }
 
92
}
 
93
 
 
94
static void
 
95
empathy_irc_network_set_property (GObject *object,
 
96
                                  guint property_id,
 
97
                                  const GValue *value,
 
98
                                  GParamSpec *pspec)
 
99
{
 
100
  EmpathyIrcNetwork *self = EMPATHY_IRC_NETWORK (object);
 
101
  EmpathyIrcNetworkPrivate *priv = EMPATHY_IRC_NETWORK_GET_PRIVATE (self);
 
102
 
 
103
  switch (property_id)
 
104
    {
 
105
      case PROP_NAME:
 
106
        if (tp_strdiff (priv->name, g_value_get_string (value)))
 
107
          {
 
108
            g_free (priv->name);
 
109
            priv->name = g_value_dup_string (value);
 
110
            g_signal_emit (object, signals[MODIFIED], 0);
 
111
          }
 
112
        break;
 
113
      case PROP_CHARSET:
 
114
        if (tp_strdiff (priv->charset, g_value_get_string (value)))
 
115
          {
 
116
            g_free (priv->charset);
 
117
            priv->charset = g_value_dup_string (value);
 
118
            g_signal_emit (object, signals[MODIFIED], 0);
 
119
          }
 
120
        break;
 
121
      default:
 
122
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
123
        break;
 
124
    }
 
125
}
 
126
 
 
127
static void
 
128
empathy_irc_network_dispose (GObject *object)
 
129
{
 
130
  EmpathyIrcNetwork *self = EMPATHY_IRC_NETWORK (object);
 
131
  EmpathyIrcNetworkPrivate *priv = EMPATHY_IRC_NETWORK_GET_PRIVATE (self);
 
132
  GSList *l;
 
133
 
 
134
  for (l = priv->servers; l != NULL; l = g_slist_next (l))
 
135
    {
 
136
      g_signal_handlers_disconnect_by_func (l->data,
 
137
          G_CALLBACK (server_modified_cb), self);
 
138
      g_object_unref (l->data);
 
139
    }
 
140
 
 
141
  G_OBJECT_CLASS (empathy_irc_network_parent_class)->dispose (object);
 
142
}
 
143
 
 
144
static void
 
145
empathy_irc_network_finalize (GObject *object)
 
146
{
 
147
  EmpathyIrcNetwork *self = EMPATHY_IRC_NETWORK (object);
 
148
  EmpathyIrcNetworkPrivate *priv = EMPATHY_IRC_NETWORK_GET_PRIVATE (self);
 
149
 
 
150
  g_slist_free (priv->servers);
 
151
  g_free (priv->name);
 
152
  g_free (priv->charset);
 
153
 
 
154
  G_OBJECT_CLASS (empathy_irc_network_parent_class)->finalize (object);
 
155
}
 
156
 
 
157
static void
 
158
empathy_irc_network_init (EmpathyIrcNetwork *self)
 
159
{
 
160
  EmpathyIrcNetworkPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 
161
      EMPATHY_TYPE_IRC_NETWORK, EmpathyIrcNetworkPrivate);
 
162
 
 
163
  self->priv = priv;
 
164
 
 
165
  priv->servers = NULL;
 
166
 
 
167
  self->user_defined = TRUE;
 
168
  self->dropped = FALSE;
 
169
}
 
170
 
 
171
static void
 
172
empathy_irc_network_class_init (EmpathyIrcNetworkClass *klass)
 
173
{
 
174
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
175
  GParamSpec *param_spec;
 
176
 
 
177
  object_class->get_property = empathy_irc_network_get_property;
 
178
  object_class->set_property = empathy_irc_network_set_property;
 
179
 
 
180
  g_type_class_add_private (object_class,
 
181
          sizeof (EmpathyIrcNetworkPrivate));
 
182
 
 
183
  object_class->dispose = empathy_irc_network_dispose;
 
184
  object_class->finalize = empathy_irc_network_finalize;
 
185
 
 
186
  param_spec = g_param_spec_string (
 
187
      "name",
 
188
      "Network name",
 
189
      "The displayed name of this network",
 
190
      NULL,
 
191
      G_PARAM_READWRITE |
 
192
      G_PARAM_STATIC_NAME |
 
193
      G_PARAM_STATIC_NICK |
 
194
      G_PARAM_STATIC_BLURB);
 
195
  g_object_class_install_property (object_class, PROP_NAME, param_spec);
 
196
 
 
197
  param_spec = g_param_spec_string (
 
198
      "charset",
 
199
      "Charset",
 
200
      "The charset to use on this network",
 
201
      "UTF-8",
 
202
      G_PARAM_CONSTRUCT |
 
203
      G_PARAM_READWRITE |
 
204
      G_PARAM_STATIC_NAME |
 
205
      G_PARAM_STATIC_NICK |
 
206
      G_PARAM_STATIC_BLURB);
 
207
  g_object_class_install_property (object_class, PROP_CHARSET, param_spec);
 
208
 
 
209
  /**
 
210
   * EmpathyIrcNetwork::modified:
 
211
   * @network: the object that received the signal
 
212
   *
 
213
   * Emitted when either a property or a server of the network is modified.
 
214
   *
 
215
   */
 
216
  signals[MODIFIED] = g_signal_new (
 
217
      "modified",
 
218
      G_OBJECT_CLASS_TYPE (object_class),
 
219
      G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 
220
      0,
 
221
      NULL, NULL,
 
222
      g_cclosure_marshal_VOID__VOID,
 
223
      G_TYPE_NONE, 0);
 
224
}
 
225
 
 
226
/**
 
227
 * empathy_irc_network_new:
 
228
 * @name: the name of the network
 
229
 *
 
230
 * Creates a new #EmpathyIrcNetwork.
 
231
 *
 
232
 * Returns: a new #EmpathyIrcNetwork
 
233
 */
 
234
EmpathyIrcNetwork *
 
235
empathy_irc_network_new (const gchar *name)
 
236
{
 
237
  return g_object_new (EMPATHY_TYPE_IRC_NETWORK,
 
238
      "name", name,
 
239
      NULL);
 
240
}
 
241
 
 
242
/**
 
243
 * empathy_irc_network_get_servers:
 
244
 * @network: an #EmpathyIrcNetwork
 
245
 *
 
246
 * Get the list of #EmpathyIrcServer that belongs to this network.
 
247
 * These servers are sorted according their priority.
 
248
 * So the first one will be the first used when trying to connect to
 
249
 * the network.
 
250
 *
 
251
 * Returns: a new #GSList of refed #EmpathyIrcServer.
 
252
 */
 
253
GSList *
 
254
empathy_irc_network_get_servers (EmpathyIrcNetwork *self)
 
255
{
 
256
  EmpathyIrcNetworkPrivate *priv;
 
257
  GSList *servers = NULL, *l;
 
258
 
 
259
  g_return_val_if_fail (EMPATHY_IS_IRC_NETWORK (self), NULL);
 
260
  priv = EMPATHY_IRC_NETWORK_GET_PRIVATE (self);
 
261
 
 
262
  for (l = priv->servers; l != NULL; l = g_slist_next (l))
 
263
    {
 
264
      servers = g_slist_prepend (servers, g_object_ref (l->data));
 
265
    }
 
266
 
 
267
  return g_slist_reverse (servers);
 
268
}
 
269
 
 
270
/**
 
271
 * empathy_irc_network_append_server:
 
272
 * @network: an #EmpathyIrcNetwork
 
273
 * @server: the #EmpathyIrcServer to add
 
274
 *
 
275
 * Add an #EmpathyIrcServer to the given #EmpathyIrcNetwork. The server
 
276
 * is added at the last position in network's servers list.
 
277
 *
 
278
 */
 
279
void
 
280
empathy_irc_network_append_server (EmpathyIrcNetwork *self,
 
281
                                   EmpathyIrcServer *server)
 
282
{
 
283
  EmpathyIrcNetworkPrivate *priv;
 
284
 
 
285
  g_return_if_fail (EMPATHY_IS_IRC_NETWORK (self));
 
286
  g_return_if_fail (server != NULL && EMPATHY_IS_IRC_SERVER (server));
 
287
 
 
288
  priv = EMPATHY_IRC_NETWORK_GET_PRIVATE (self);
 
289
 
 
290
  g_return_if_fail (g_slist_find (priv->servers, server) == NULL);
 
291
 
 
292
  priv->servers = g_slist_append (priv->servers, g_object_ref (server));
 
293
 
 
294
  g_signal_connect (server, "modified", G_CALLBACK (server_modified_cb), self);
 
295
 
 
296
  g_signal_emit (self, signals[MODIFIED], 0);
 
297
}
 
298
 
 
299
/**
 
300
 * empathy_irc_network_remove_server:
 
301
 * @network: an #EmpathyIrcNetwork
 
302
 * @server: the #EmpathyIrcServer to remove
 
303
 *
 
304
 * Remove an #EmpathyIrcServer from the servers list of the
 
305
 * given #EmpathyIrcNetwork.
 
306
 *
 
307
 */
 
308
void
 
309
empathy_irc_network_remove_server (EmpathyIrcNetwork *self,
 
310
                                   EmpathyIrcServer *server)
 
311
{
 
312
  EmpathyIrcNetworkPrivate *priv;
 
313
  GSList *l;
 
314
 
 
315
  g_return_if_fail (EMPATHY_IS_IRC_NETWORK (self));
 
316
  g_return_if_fail (server != NULL && EMPATHY_IS_IRC_SERVER (server));
 
317
 
 
318
  priv = EMPATHY_IRC_NETWORK_GET_PRIVATE (self);
 
319
 
 
320
  l = g_slist_find (priv->servers, server);
 
321
  if (l == NULL)
 
322
    return;
 
323
 
 
324
  g_object_unref (l->data);
 
325
  priv->servers = g_slist_delete_link (priv->servers, l);
 
326
  g_signal_handlers_disconnect_by_func (server, G_CALLBACK (server_modified_cb),
 
327
      self);
 
328
 
 
329
  g_signal_emit (self, signals[MODIFIED], 0);
 
330
}
 
331
 
 
332
/**
 
333
 * empathy_irc_network_set_server_position:
 
334
 * @network: an #EmpathyIrcNetwork
 
335
 * @server: the #EmpathyIrcServer to move
 
336
 * @pos: the position to move the server. If this is negative, or is larger than
 
337
 * the number of servers in the list, the server is moved to the end of the
 
338
 * list.
 
339
 *
 
340
 * Move an #EmpathyIrcServer in the servers list of the given
 
341
 * #EmpathyIrcNetwork.
 
342
 *
 
343
 */
 
344
void
 
345
empathy_irc_network_set_server_position (EmpathyIrcNetwork *self,
 
346
                                         EmpathyIrcServer *server,
 
347
                                         gint pos)
 
348
{
 
349
  EmpathyIrcNetworkPrivate *priv;
 
350
  GSList *l;
 
351
 
 
352
  g_return_if_fail (EMPATHY_IS_IRC_NETWORK (self));
 
353
  g_return_if_fail (server != NULL && EMPATHY_IS_IRC_SERVER (server));
 
354
 
 
355
  priv = EMPATHY_IRC_NETWORK_GET_PRIVATE (self);
 
356
 
 
357
  l = g_slist_find (priv->servers, server);
 
358
  if (l == NULL)
 
359
    return;
 
360
 
 
361
  priv->servers = g_slist_delete_link (priv->servers, l);
 
362
  priv->servers = g_slist_insert (priv->servers, server, pos);
 
363
 
 
364
  g_signal_emit (self, signals[MODIFIED], 0);
 
365
}