← Back to branch summary

~ubuntu-branches/ubuntu/precise/evolution/precise

« back to all changes in this revision

Viewing changes to mail/em-filter-folder-element.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Trudel-Lapierre
  • Date: 2011-06-24 00:27:53 UTC
  • mfrom: (1.1.80 upstream)
  • Revision ID: james.westby@ubuntu.com-20110624002753-2vh1vjavlya7r103
Tags: 3.1.2-0ubuntu1
* New upstream release 3.1.2.
* debian/control: adjust Build-Depends to match new upstream requirements for
  the new release.
* debian/control: update evolution and evolution-dev Depends to require the
  right versions of e-d-s (>= 3.1, << 3.2), and drop libunique-3.0-dev.
* debian/control,
  debian/evolution.install: remove groupwise-features from the plugin list,
  it's now split out into a separate module.
* debian/patches/03_lpi.patch: refreshed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mail/em-filter-folder-element.c
39
39
#include "libedataserver/e-sexp.h"
40
40
#include "e-util/e-alert.h"
41
41
 
 
42
#define EM_FILTER_FOLDER_ELEMENT_GET_PRIVATE(obj) \
 
43
        (G_TYPE_INSTANCE_GET_PRIVATE \
 
44
        ((obj), EM_TYPE_FILTER_FOLDER_ELEMENT, EMFilterFolderElementPrivate))
 
45
 
42
46
struct _EMFilterFolderElementPrivate {
43
 
        EMailSession *session;
 
47
        EMailBackend *backend;
44
48
        gchar *uri;
45
49
};
46
50
 
47
51
enum {
48
52
        PROP_0,
49
 
        PROP_SESSION
 
53
        PROP_BACKEND
50
54
};
51
55
 
52
 
static gboolean validate (EFilterElement *fe, EAlert **alert);
53
 
static gint folder_eq (EFilterElement *fe, EFilterElement *cm);
54
 
static xmlNodePtr xml_encode (EFilterElement *fe);
55
 
static gint xml_decode (EFilterElement *fe, xmlNodePtr node);
56
 
static GtkWidget *get_widget (EFilterElement *fe);
57
 
static void build_code (EFilterElement *fe, GString *out, EFilterPart *ff);
58
 
static void format_sexp (EFilterElement *, GString *);
59
 
static void emff_copy_value (EFilterElement *de, EFilterElement *se);
60
 
 
61
56
G_DEFINE_TYPE (
62
57
        EMFilterFolderElement,
63
58
        em_filter_folder_element,
64
59
        E_TYPE_FILTER_ELEMENT)
65
60
 
66
61
static void
67
 
filter_folder_element_set_session (EMFilterFolderElement *element,
68
 
                                   EMailSession *session)
69
 
{
70
 
        if (!session)
71
 
                session = e_mail_backend_get_session (
72
 
                        E_MAIL_BACKEND (e_shell_get_backend_by_name (
73
 
                        e_shell_get_default (), "mail")));
74
 
 
75
 
        g_return_if_fail (E_IS_MAIL_SESSION (session));
76
 
        g_return_if_fail (element->priv->session == NULL);
77
 
 
78
 
        element->priv->session = g_object_ref (session);
 
62
filter_folder_element_selected_cb (EMFolderSelectionButton *button,
 
63
                                   EMFilterFolderElement *ff)
 
64
{
 
65
        GtkWidget *toplevel;
 
66
        const gchar *uri;
 
67
 
 
68
        uri = em_folder_selection_button_get_selection (button);
 
69
 
 
70
        g_free (ff->priv->uri);
 
71
        ff->priv->uri = g_strdup (uri);
 
72
 
 
73
        toplevel = gtk_widget_get_toplevel (GTK_WIDGET (button));
 
74
        gtk_window_present (GTK_WINDOW (toplevel));
 
75
}
 
76
 
 
77
static void
 
78
filter_folder_element_set_backend (EMFilterFolderElement *element,
 
79
                                   EMailBackend *backend)
 
80
{
 
81
        /* FIXME Dirty hack.  Backend should be passed in always. */
 
82
        if (backend == NULL) {
 
83
                EShellBackend *shell_backend;
 
84
                EShell *shell;
 
85
 
 
86
                shell = e_shell_get_default ();
 
87
                shell_backend = e_shell_get_backend_by_name (shell, "mail");
 
88
                backend = E_MAIL_BACKEND (shell_backend);
 
89
        }
 
90
 
 
91
        g_return_if_fail (E_IS_MAIL_BACKEND (backend));
 
92
        g_return_if_fail (element->priv->backend == NULL);
 
93
 
 
94
        element->priv->backend = g_object_ref (backend);
79
95
}
80
96
 
81
97
static void
85
101
                                    GParamSpec *pspec)
86
102
{
87
103
        switch (property_id) {
88
 
                case PROP_SESSION:
89
 
                        filter_folder_element_set_session (
 
104
                case PROP_BACKEND:
 
105
                        filter_folder_element_set_backend (
90
106
                                EM_FILTER_FOLDER_ELEMENT (object),
91
107
                                g_value_get_object (value));
92
108
                        return;
102
118
                                    GParamSpec *pspec)
103
119
{
104
120
        switch (property_id) {
105
 
                case PROP_SESSION:
 
121
                case PROP_BACKEND:
106
122
                        g_value_set_object (
107
123
                                value,
108
 
                                em_filter_folder_element_get_session (
 
124
                                em_filter_folder_element_get_backend (
109
125
                                EM_FILTER_FOLDER_ELEMENT (object)));
110
126
                        return;
111
127
        }
118
134
{
119
135
        EMFilterFolderElementPrivate *priv;
120
136
 
121
 
        priv = EM_FILTER_FOLDER_ELEMENT (object)->priv;
 
137
        priv = EM_FILTER_FOLDER_ELEMENT_GET_PRIVATE (object);
122
138
 
123
 
        if (priv->session != NULL) {
124
 
                g_object_unref (priv->session);
125
 
                priv->session = NULL;
 
139
        if (priv->backend != NULL) {
 
140
                g_object_unref (priv->backend);
 
141
                priv->backend = NULL;
126
142
        }
127
143
 
128
144
        /* Chain up to parent's dispose() method. */
134
150
{
135
151
        EMFilterFolderElementPrivate *priv;
136
152
 
137
 
        priv = EM_FILTER_FOLDER_ELEMENT (object)->priv;
 
153
        priv = EM_FILTER_FOLDER_ELEMENT_GET_PRIVATE (object);
138
154
 
139
155
        g_free (priv->uri);
140
156
 
142
158
        G_OBJECT_CLASS (em_filter_folder_element_parent_class)->finalize (object);
143
159
}
144
160
 
 
161
static gboolean
 
162
filter_folder_element_validate (EFilterElement *fe,
 
163
                                EAlert **alert)
 
164
{
 
165
        EMFilterFolderElement *ff = (EMFilterFolderElement *) fe;
 
166
 
 
167
        g_warn_if_fail (alert == NULL || *alert == NULL);
 
168
 
 
169
        if (ff->priv->uri != NULL && *ff->priv->uri != '\0')
 
170
                return TRUE;
 
171
 
 
172
        if (alert)
 
173
                *alert = e_alert_new ("mail:no-folder", NULL);
 
174
 
 
175
        return FALSE;
 
176
}
 
177
 
 
178
static gint
 
179
filter_folder_element_eq (EFilterElement *fe,
 
180
                          EFilterElement *cm)
 
181
{
 
182
        return E_FILTER_ELEMENT_CLASS (
 
183
                em_filter_folder_element_parent_class)->eq (fe, cm) &&
 
184
                strcmp (((EMFilterFolderElement *) fe)->priv->uri,
 
185
                ((EMFilterFolderElement *) cm)->priv->uri)== 0;
 
186
}
 
187
 
 
188
static xmlNodePtr
 
189
filter_folder_element_xml_encode (EFilterElement *fe)
 
190
{
 
191
        xmlNodePtr value, work;
 
192
        EMFilterFolderElement *ff = (EMFilterFolderElement *) fe;
 
193
 
 
194
        value = xmlNewNode (NULL, (xmlChar *) "value");
 
195
        xmlSetProp (value, (xmlChar *) "name", (xmlChar *) fe->name);
 
196
        xmlSetProp (value, (xmlChar *) "type", (xmlChar *) "folder");
 
197
 
 
198
        work = xmlNewChild (value, NULL, (xmlChar *) "folder", NULL);
 
199
        xmlSetProp (work, (xmlChar *) "uri", (xmlChar *) ff->priv->uri);
 
200
 
 
201
        return value;
 
202
}
 
203
 
 
204
static gint
 
205
filter_folder_element_xml_decode (EFilterElement *fe,
 
206
                                  xmlNodePtr node)
 
207
{
 
208
        EMFilterFolderElement *ff = (EMFilterFolderElement *) fe;
 
209
        xmlNodePtr n;
 
210
 
 
211
        xmlFree (fe->name);
 
212
        fe->name = (gchar *) xmlGetProp(node, (xmlChar *) "name");
 
213
 
 
214
        n = node->children;
 
215
        while (n) {
 
216
                if (!strcmp((gchar *) n->name, "folder")) {
 
217
                        gchar *uri;
 
218
 
 
219
                        uri = (gchar *) xmlGetProp(n, (xmlChar *) "uri");
 
220
                        g_free (ff->priv->uri);
 
221
                        ff->priv->uri = g_strdup (uri);
 
222
                        xmlFree (uri);
 
223
                        break;
 
224
                }
 
225
                n = n->next;
 
226
        }
 
227
 
 
228
        return 0;
 
229
}
 
230
 
 
231
static GtkWidget *
 
232
filter_folder_element_get_widget (EFilterElement *fe)
 
233
{
 
234
        EMFilterFolderElement *ff = (EMFilterFolderElement *) fe;
 
235
        EMailBackend *backend;
 
236
        GtkWidget *button;
 
237
 
 
238
        backend = em_filter_folder_element_get_backend (ff);
 
239
 
 
240
        button = em_folder_selection_button_new (
 
241
                backend, _("Select Folder"), NULL);
 
242
        em_folder_selection_button_set_selection (
 
243
                EM_FOLDER_SELECTION_BUTTON (button), ff->priv->uri);
 
244
        gtk_widget_show (button);
 
245
 
 
246
        g_signal_connect (
 
247
                button, "selected",
 
248
                G_CALLBACK (filter_folder_element_selected_cb), ff);
 
249
 
 
250
        return button;
 
251
}
 
252
 
 
253
static void
 
254
filter_folder_element_build_code (EFilterElement *fe,
 
255
                                  GString *out,
 
256
                                  EFilterPart *ff)
 
257
{
 
258
        /* We are doing nothing on purpose. */
 
259
}
 
260
 
 
261
static void
 
262
filter_folder_element_format_sexp (EFilterElement *fe,
 
263
                                   GString *out)
 
264
{
 
265
        EMFilterFolderElement *ff = (EMFilterFolderElement *) fe;
 
266
 
 
267
        e_sexp_encode_string (out, ff->priv->uri);
 
268
}
 
269
 
 
270
static void
 
271
filter_folder_element_copy_value (EFilterElement *de,
 
272
                                  EFilterElement *se)
 
273
{
 
274
        if (EM_IS_FILTER_FOLDER_ELEMENT (se)) {
 
275
                em_filter_folder_element_set_uri (
 
276
                        EM_FILTER_FOLDER_ELEMENT (de),
 
277
                        EM_FILTER_FOLDER_ELEMENT (se)->priv->uri);
 
278
        } else {
 
279
                E_FILTER_ELEMENT_CLASS (
 
280
                em_filter_folder_element_parent_class)->copy_value (de, se);
 
281
        }
 
282
}
145
283
static void
146
284
em_filter_folder_element_class_init (EMFilterFolderElementClass *class)
147
285
{
157
295
        object_class->finalize = filter_folder_element_finalize;
158
296
 
159
297
        filter_element_class = E_FILTER_ELEMENT_CLASS (class);
160
 
        filter_element_class->validate = validate;
161
 
        filter_element_class->eq = folder_eq;
162
 
        filter_element_class->xml_encode = xml_encode;
163
 
        filter_element_class->xml_decode = xml_decode;
164
 
        filter_element_class->get_widget = get_widget;
165
 
        filter_element_class->build_code = build_code;
166
 
        filter_element_class->format_sexp = format_sexp;
167
 
        filter_element_class->copy_value = emff_copy_value;
 
298
        filter_element_class->validate = filter_folder_element_validate;
 
299
        filter_element_class->eq = filter_folder_element_eq;
 
300
        filter_element_class->xml_encode = filter_folder_element_xml_encode;
 
301
        filter_element_class->xml_decode = filter_folder_element_xml_decode;
 
302
        filter_element_class->get_widget = filter_folder_element_get_widget;
 
303
        filter_element_class->build_code = filter_folder_element_build_code;
 
304
        filter_element_class->format_sexp = filter_folder_element_format_sexp;
 
305
        filter_element_class->copy_value = filter_folder_element_copy_value;
168
306
 
169
307
        g_object_class_install_property (
170
308
                object_class,
171
 
                PROP_SESSION,
 
309
                PROP_BACKEND,
172
310
                g_param_spec_object (
173
 
                        "session",
174
 
                        NULL,
175
 
                        NULL,
176
 
                        E_TYPE_MAIL_SESSION,
 
311
                        "backend",
 
312
                        NULL,
 
313
                        NULL,
 
314
                        E_TYPE_MAIL_BACKEND,
177
315
                        G_PARAM_READWRITE |
178
316
                        G_PARAM_CONSTRUCT_ONLY));
179
317
}
181
319
static void
182
320
em_filter_folder_element_init (EMFilterFolderElement *element)
183
321
{
184
 
        element->priv = G_TYPE_INSTANCE_GET_PRIVATE (
185
 
                element, EM_TYPE_FILTER_FOLDER_ELEMENT,
186
 
                EMFilterFolderElementPrivate);
 
322
        element->priv = EM_FILTER_FOLDER_ELEMENT_GET_PRIVATE (element);
187
323
}
188
324
 
189
325
EFilterElement *
190
 
em_filter_folder_element_new (EMailSession *session)
 
326
em_filter_folder_element_new (EMailBackend *backend)
191
327
{
192
 
        g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);
 
328
        g_return_val_if_fail (E_IS_MAIL_BACKEND (backend), NULL);
193
329
 
194
330
        return g_object_new (
195
331
                EM_TYPE_FILTER_FOLDER_ELEMENT,
196
 
                "session", session, NULL);
 
332
                "backend", backend, NULL);
197
333
}
198
334
 
199
 
EMailSession *
200
 
em_filter_folder_element_get_session (EMFilterFolderElement *element)
 
335
EMailBackend *
 
336
em_filter_folder_element_get_backend (EMFilterFolderElement *element)
201
337
{
202
338
        g_return_val_if_fail (EM_IS_FILTER_FOLDER_ELEMENT (element), NULL);
203
339
 
204
 
        return element->priv->session;
 
340
        return element->priv->backend;
205
341
}
206
342
 
207
343
const gchar *
222
358
        element->priv->uri = g_strdup (uri);
223
359
}
224
360
 
225
 
static gboolean
226
 
validate (EFilterElement *fe, EAlert **alert)
227
 
{
228
 
        EMFilterFolderElement *ff = (EMFilterFolderElement *)fe;
229
 
 
230
 
        g_warn_if_fail (alert == NULL || *alert == NULL);
231
 
 
232
 
        if (ff->priv->uri && *ff->priv->uri) {
233
 
                return TRUE;
234
 
        } else {
235
 
                if (alert)
236
 
                        *alert = e_alert_new ("mail:no-folder", NULL);
237
 
 
238
 
                return FALSE;
239
 
        }
240
 
}
241
 
 
242
 
static gint
243
 
folder_eq (EFilterElement *fe, EFilterElement *cm)
244
 
{
245
 
        return E_FILTER_ELEMENT_CLASS (
246
 
                em_filter_folder_element_parent_class)->eq (fe, cm) &&
247
 
                strcmp (((EMFilterFolderElement *)fe)->priv->uri,
248
 
                ((EMFilterFolderElement *)cm)->priv->uri)== 0;
249
 
}
250
 
 
251
 
static xmlNodePtr
252
 
xml_encode (EFilterElement *fe)
253
 
{
254
 
        xmlNodePtr value, work;
255
 
        EMFilterFolderElement *ff = (EMFilterFolderElement *)fe;
256
 
 
257
 
        value = xmlNewNode(NULL, (const guchar *)"value");
258
 
        xmlSetProp(value, (const guchar *)"name", (guchar *)fe->name);
259
 
        if (ff->store_camel_uri)
260
 
                xmlSetProp(value, (const guchar *)"type", (const guchar *)"folder-curi");
261
 
        else
262
 
                xmlSetProp(value, (const guchar *)"type", (const guchar *)"folder");
263
 
 
264
 
        work = xmlNewChild(value, NULL, (const guchar *)"folder", NULL);
265
 
        xmlSetProp(work, (const guchar *)"uri", (const guchar *)ff->priv->uri);
266
 
 
267
 
        return value;
268
 
}
269
 
 
270
 
static gint
271
 
xml_decode (EFilterElement *fe, xmlNodePtr node)
272
 
{
273
 
        EMFilterFolderElement *ff = (EMFilterFolderElement *)fe;
274
 
        xmlNodePtr n;
275
 
        xmlChar *type;
276
 
 
277
 
        xmlFree (fe->name);
278
 
        fe->name = (gchar *)xmlGetProp(node, (const guchar *)"name");
279
 
 
280
 
        type = xmlGetProp (node, (const guchar *)"type");
281
 
        if (type) {
282
 
                ff->store_camel_uri = g_str_equal ((const gchar *)type, "folder-curi");
283
 
                xmlFree (type);
284
 
        } else {
285
 
                ff->store_camel_uri = FALSE;
286
 
        }
287
 
 
288
 
        n = node->children;
289
 
        while (n) {
290
 
                if (!strcmp((gchar *)n->name, "folder")) {
291
 
                        gchar *uri;
292
 
 
293
 
                        uri = (gchar *)xmlGetProp(n, (const guchar *)"uri");
294
 
                        g_free (ff->priv->uri);
295
 
                        ff->priv->uri = g_strdup (uri);
296
 
                        xmlFree (uri);
297
 
                        break;
298
 
                }
299
 
                n = n->next;
300
 
        }
301
 
 
302
 
        return 0;
303
 
}
304
 
 
305
 
static void
306
 
folder_selected (EMFolderSelectionButton *button, EMFilterFolderElement *ff)
307
 
{
308
 
        GtkWidget *toplevel;
309
 
        const gchar *uri;
310
 
 
311
 
        uri = em_folder_selection_button_get_selection (button);
312
 
        g_free (ff->priv->uri);
313
 
 
314
 
        if (ff->store_camel_uri)
315
 
                ff->priv->uri = g_strdup (uri);
316
 
        else
317
 
                ff->priv->uri = uri != NULL ? em_uri_from_camel (uri) : NULL;
318
 
 
319
 
        toplevel = gtk_widget_get_toplevel (GTK_WIDGET (button));
320
 
        gtk_window_present (GTK_WINDOW (toplevel));
321
 
}
322
 
 
323
 
static GtkWidget *
324
 
get_widget (EFilterElement *fe)
325
 
{
326
 
        EMFilterFolderElement *ff = (EMFilterFolderElement *)fe;
327
 
        EMailSession *session;
328
 
        GtkWidget *button;
329
 
        gchar *uri;
330
 
 
331
 
        session = em_filter_folder_element_get_session (ff);
332
 
 
333
 
        if (ff->store_camel_uri)
334
 
                uri = ff->priv->uri;
335
 
        else
336
 
                uri = em_uri_to_camel (ff->priv->uri);
337
 
 
338
 
        button = em_folder_selection_button_new (
339
 
                session, _("Select Folder"), NULL);
340
 
 
341
 
        em_folder_selection_button_set_selection (
342
 
                EM_FOLDER_SELECTION_BUTTON (button), uri);
343
 
 
344
 
        if (!ff->store_camel_uri)
345
 
                g_free (uri);
346
 
 
347
 
        gtk_widget_show (button);
348
 
        g_signal_connect(button, "selected", G_CALLBACK(folder_selected), ff);
349
 
 
350
 
        return button;
351
 
}
352
 
 
353
 
static void
354
 
build_code (EFilterElement *fe, GString *out, EFilterPart *ff)
355
 
{
356
 
        return;
357
 
}
358
 
 
359
 
static void
360
 
format_sexp (EFilterElement *fe, GString *out)
361
 
{
362
 
        EMFilterFolderElement *ff = (EMFilterFolderElement *)fe;
363
 
 
364
 
        e_sexp_encode_string (out, ff->priv->uri);
365
 
}
366
 
 
367
 
static void
368
 
emff_copy_value (EFilterElement *de, EFilterElement *se)
369
 
{
370
 
        if (EM_IS_FILTER_FOLDER_ELEMENT (se)) {
371
 
                ((EMFilterFolderElement *)de)->store_camel_uri =
372
 
                        ((EMFilterFolderElement *)se)->store_camel_uri;
373
 
                em_filter_folder_element_set_uri ((
374
 
                        EMFilterFolderElement *) de,
375
 
                        ((EMFilterFolderElement *) se)->priv->uri);
376
 
        } else
377
 
                E_FILTER_ELEMENT_CLASS (em_filter_folder_element_parent_class)->copy_value (de, se);
378
 
}