git.maemo.org Git - modest/blob - src/modest-editor-window.c

   1 /* Copyright (c) 2006, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30
  31 /* modest-editor-window.c */
  32
  33 #include "modest-ui.h"
  34 #include "modest-editor-window.h"
  35
  36 /* 'private'/'protected' functions */
  37 static void                      modest_editor_window_class_init    (ModestEditorWindowClass *klass);
  38 static void                      modest_editor_window_init          (ModestEditorWindow *obj);
  39 static void                      modest_editor_window_finalize      (GObject *obj);
  40
  41 /* list my signals */
  42 enum {
  43         /* MY_SIGNAL_1, */
  44         /* MY_SIGNAL_2, */
  45         LAST_SIGNAL
  46 };
  47
  48 typedef struct _ModestEditorWindowPrivate ModestEditorWindowPrivate;
  49 struct _ModestEditorWindowPrivate {
  50         GtkWidget *window;
  51         gpointer user_data;
  52         gboolean modified;
  53         GList *attachments;
  54         gchar *identity;
  55         gchar *transport;
  56 };
  57 #define MODEST_EDITOR_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  58                                                   MODEST_TYPE_EDITOR_WINDOW, \
  59                                                   ModestEditorWindowPrivate))
  60 /* globals */
  61 static GObjectClass *parent_class = NULL;
  62
  63 /* uncomment the following if you have defined any signals */
  64 /* static guint signals[LAST_SIGNAL] = {0}; */
  65
  66 GType
  67 modest_editor_window_get_type (void)
  68 {
  69         static GType my_type = 0;
  70         if (!my_type) {
  71                 static const GTypeInfo my_info = {
  72                         sizeof(ModestEditorWindowClass),
  73                         NULL,           /* base init */
  74                         NULL,           /* base finalize */
  75                         (GClassInitFunc) modest_editor_window_class_init,
  76                         NULL,           /* class finalize */
  77                         NULL,           /* class data */
  78                         sizeof(ModestEditorWindow),
  79                         1,              /* n_preallocs */
  80                         (GInstanceInitFunc) modest_editor_window_init,
  81                 };
  82                 my_type = g_type_register_static (G_TYPE_OBJECT,
  83                                                   "ModestEditorWindow",
  84                                                   &my_info, 0);
  85         }
  86         return my_type;
  87 }
  88
  89 static void
  90 modest_editor_window_class_init (ModestEditorWindowClass *klass)
  91 {
  92         GObjectClass *gobject_class;
  93         gobject_class = (GObjectClass*) klass;
  94
  95         parent_class            = g_type_class_peek_parent (klass);
  96         gobject_class->finalize = modest_editor_window_finalize;
  97
  98         g_type_class_add_private (gobject_class, sizeof(ModestEditorWindowPrivate));
  99
 100 }
 101
 102 static void
 103 modest_editor_window_init (ModestEditorWindow *obj)
 104 {
 105         ModestEditorWindowPrivate *priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(obj);
 106
 107         priv->user_data = NULL;
 108         priv->modified = FALSE;
 109         priv->attachments = NULL;
 110         priv->identity = NULL;
 111         priv->transport = NULL;
 112         obj->window = NULL;
 113 }
 114
 115 static void
 116 modest_editor_window_finalize (GObject *obj)
 117 {
 118         ModestEditorWindowPrivate *priv;
 119
 120         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(obj);
 121
 122         if (priv->user_data)
 123                 g_free(priv->user_data);
 124
 125         modest_editor_window_set_attachments(MODEST_EDITOR_WINDOW(obj), NULL);
 126         g_free(priv->identity);
 127         g_free(priv->transport);
 128         g_object_unref (MODEST_EDITOR_WINDOW(obj)->window);
 129         MODEST_EDITOR_WINDOW(obj)->window = NULL;
 130
 131         G_OBJECT_CLASS(parent_class)->finalize (obj);
 132 }
 133
 134 GObject*
 135 modest_editor_window_new (ModestUI *ui)
 136 {
 137         GObject *self;
 138         ModestEditorWindowPrivate *priv;
 139         GObject *edit_win;
 140         gpointer data;
 141
 142         self = G_OBJECT(g_object_new(MODEST_TYPE_EDITOR_WINDOW, NULL));
 143         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(self);
 144
 145         /* for now create a local test-window */
 146
 147         data = NULL;
 148         edit_win = modest_ui_new_editor_window(ui, &data);
 149
 150         if (!edit_win)
 151                 return NULL;
 152         if (!data)
 153                 g_message("editor window user data is emtpy");
 154
 155         MODEST_EDITOR_WINDOW(self)->window = edit_win;
 156         priv->user_data = data;
 157
 158         return self;
 159 }
 160
 161 /*
 162  * return user defined data from a ModestEditorWindow instance
 163  * like e.g. a refernce to a GladeXML*
 164  */
 165 gpointer modest_editor_window_get_data(ModestEditorWindow *edit_win)
 166 {
 167         ModestEditorWindowPrivate *priv;
 168
 169         if (!edit_win) {
 170                 return NULL;
 171         }
 172         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 173
 174         // g_message("get priv->data = %p", priv->user_data);
 175
 176         return priv->user_data;
 177 }
 178
 179 gboolean modest_editor_window_set_modified(ModestEditorWindow *edit_win, gboolean modified)
 180 {
 181         ModestEditorWindowPrivate *priv;
 182
 183         if (!edit_win) {
 184                 return FALSE;
 185         }
 186         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 187
 188         priv->modified = modified;
 189
 190         return priv->modified;
 191 }
 192
 193 gboolean modest_editor_window_get_modified(ModestEditorWindow *edit_win)
 194 {
 195         ModestEditorWindowPrivate *priv;
 196
 197         if (!edit_win) {
 198                 return FALSE;
 199         }
 200         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 201
 202         // g_message("get priv->data = %p", priv->user_data);
 203
 204         return priv->modified;
 205 }
 206
 207 gboolean modest_editor_window_set_to_header(ModestEditorWindow *edit_win, const gchar *to)
 208 {
 209         ModestEditorWindowPrivate *priv;
 210
 211
 212         if (!edit_win)
 213                 return FALSE;
 214         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 215
 216         return modest_ui_editor_window_set_to_header(to, priv->user_data);
 217 }
 218
 219
 220 gboolean modest_editor_window_set_cc_header(ModestEditorWindow *edit_win, const gchar *cc)
 221 {
 222         ModestEditorWindowPrivate *priv;
 223
 224
 225         if (!edit_win)
 226                 return FALSE;
 227         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 228
 229         return modest_ui_editor_window_set_cc_header(cc, priv->user_data);
 230 }
 231
 232 gboolean modest_editor_window_set_bcc_header(ModestEditorWindow *edit_win, const gchar *bcc)
 233 {
 234         ModestEditorWindowPrivate *priv;
 235
 236
 237         if (!edit_win)
 238                 return FALSE;
 239         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 240
 241         return modest_ui_editor_window_set_bcc_header(bcc, priv->user_data);
 242 }
 243
 244 gboolean modest_editor_window_set_subject_header(ModestEditorWindow *edit_win, const gchar *subject)
 245 {
 246         ModestEditorWindowPrivate *priv;
 247
 248
 249         if (!edit_win)
 250                 return FALSE;
 251         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 252
 253         return modest_ui_editor_window_set_subject_header(subject, priv->user_data);
 254 }
 255
 256 gboolean modest_editor_window_set_body(ModestEditorWindow *edit_win, const gchar *body)
 257 {
 258         ModestEditorWindowPrivate *priv;
 259
 260
 261         if (!edit_win)
 262                 return FALSE;
 263         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 264
 265         return modest_ui_editor_window_set_body(body, priv->user_data);
 266 }
 267
 268
 269 gboolean modest_editor_window_attach_file(ModestEditorWindow *edit_win, ModestTnyAttachment *attachment)
 270 {
 271         ModestEditorWindowPrivate *priv;
 272
 273         if (!edit_win)
 274                 return FALSE;
 275         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 276
 277         priv->attachments = g_list_append(
 278                                                         priv->attachments,
 279                                                         attachment);
 280
 281         return modest_ui_editor_window_update_attachments(priv->user_data);
 282 }
 283
 284 GList * modest_editor_window_set_attachments(ModestEditorWindow *edit_win, const GList* attachments)
 285 {
 286         ModestEditorWindowPrivate *priv;
 287         GList *pos;
 288
 289         g_return_val_if_fail(edit_win, NULL);
 290
 291         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 292
 293         modest_tny_attachment_free_list(priv->attachments);
 294         priv->attachments = g_list_copy((GList *)attachments);
 295         for (pos = priv->attachments ; pos ; pos = pos->next )
 296                 g_object_ref(pos->data);
 297         return priv->attachments;
 298 }
 299
 300 GList * modest_editor_window_get_attachments(ModestEditorWindow *edit_win)
 301 {
 302         ModestEditorWindowPrivate *priv;
 303
 304         g_return_val_if_fail(edit_win, NULL);
 305
 306         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 307         return priv->attachments;
 308 }
 309
 310
 311 void
 312 modest_editor_window_set_identity(ModestEditorWindow *edit_win, const gchar *identity)
 313 {
 314         ModestEditorWindowPrivate *priv;
 315
 316         g_return_if_fail(edit_win);
 317
 318         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 319
 320         g_free(priv->identity);
 321         priv->identity = g_strdup(identity);
 322 }
 323
 324
 325 const gchar *
 326 modest_editor_window_get_identity(ModestEditorWindow *edit_win)
 327 {
 328         ModestEditorWindowPrivate *priv;
 329
 330         g_return_val_if_fail(edit_win, NULL);
 331
 332         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 333
 334         return priv->identity;
 335 }
 336
 337
 338 void
 339 modest_editor_window_set_transport(ModestEditorWindow *edit_win, const gchar *transport)
 340 {
 341         ModestEditorWindowPrivate *priv;
 342
 343         g_return_if_fail(edit_win);
 344
 345         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 346
 347         g_free(priv->transport);
 348         priv->transport = g_strdup(transport);
 349 }
 350
 351
 352 const gchar *
 353 modest_editor_window_get_transport(ModestEditorWindow *edit_win)
 354 {
 355         ModestEditorWindowPrivate *priv;
 356
 357         g_return_val_if_fail(edit_win, NULL);
 358
 359         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 360
 361         return priv->transport;
 362 }