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 #include "modest-ui.h"
  31 #include "modest-editor-window.h"
  32
  33 /* 'private'/'protected' functions */
  34 static void                      modest_editor_window_class_init    (ModestEditorWindowClass *klass);
  35 static void                      modest_editor_window_init          (ModestEditorWindow *obj);
  36 static void                      modest_editor_window_finalize      (GObject *obj);
  37
  38 /* list my signals */
  39 enum {
  40         /* MY_SIGNAL_1, */
  41         /* MY_SIGNAL_2, */
  42         LAST_SIGNAL
  43 };
  44
  45 typedef struct _ModestEditorWindowPrivate ModestEditorWindowPrivate;
  46 struct _ModestEditorWindowPrivate {
  47         GtkWidget *window;
  48         gpointer user_data;
  49         gboolean modified;
  50         GList *attachments;
  51         gchar *identity;
  52         gchar *transport;
  53 };
  54 #define MODEST_EDITOR_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  55                                                   MODEST_TYPE_EDITOR_WINDOW, \
  56                                                   ModestEditorWindowPrivate))
  57 /* globals */
  58 static GObjectClass *parent_class = NULL;
  59
  60 /* uncomment the following if you have defined any signals */
  61 /* static guint signals[LAST_SIGNAL] = {0}; */
  62
  63 GType
  64 modest_editor_window_get_type (void)
  65 {
  66         static GType my_type = 0;
  67         if (!my_type) {
  68                 static const GTypeInfo my_info = {
  69                         sizeof(ModestEditorWindowClass),
  70                         NULL,           /* base init */
  71                         NULL,           /* base finalize */
  72                         (GClassInitFunc) modest_editor_window_class_init,
  73                         NULL,           /* class finalize */
  74                         NULL,           /* class data */
  75                         sizeof(ModestEditorWindow),
  76                         1,              /* n_preallocs */
  77                         (GInstanceInitFunc) modest_editor_window_init,
  78                 };
  79                 my_type = g_type_register_static (G_TYPE_OBJECT,
  80                                                   "ModestEditorWindow",
  81                                                   &my_info, 0);
  82         }
  83         return my_type;
  84 }
  85
  86 static void
  87 modest_editor_window_class_init (ModestEditorWindowClass *klass)
  88 {
  89         GObjectClass *gobject_class;
  90         gobject_class = (GObjectClass*) klass;
  91
  92         parent_class            = g_type_class_peek_parent (klass);
  93         gobject_class->finalize = modest_editor_window_finalize;
  94
  95         g_type_class_add_private (gobject_class, sizeof(ModestEditorWindowPrivate));
  96
  97 }
  98
  99 static void
 100 modest_editor_window_init (ModestEditorWindow *obj)
 101 {
 102         ModestEditorWindowPrivate *priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(obj);
 103
 104         priv->user_data = NULL;
 105         priv->modified = FALSE;
 106         priv->attachments = NULL;
 107         priv->identity = NULL;
 108         priv->transport = NULL;
 109         obj->window = NULL;
 110 }
 111
 112 static void
 113 modest_editor_window_finalize (GObject *obj)
 114 {
 115         ModestEditorWindowPrivate *priv;
 116
 117         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(obj);
 118
 119         if (priv->user_data)
 120                 g_free(priv->user_data);
 121
 122         modest_editor_window_set_attachments(MODEST_EDITOR_WINDOW(obj), NULL);
 123         g_free(priv->identity);
 124         g_free(priv->transport);
 125         g_object_unref (MODEST_EDITOR_WINDOW(obj)->window);
 126         MODEST_EDITOR_WINDOW(obj)->window = NULL;
 127
 128         G_OBJECT_CLASS(parent_class)->finalize (obj);
 129 }
 130
 131 GObject*
 132 modest_editor_window_new (ModestUI *ui)
 133 {
 134         GObject *self;
 135         ModestEditorWindowPrivate *priv;
 136         GObject *edit_win;
 137         gpointer data;
 138
 139         self = G_OBJECT(g_object_new(MODEST_TYPE_EDITOR_WINDOW, NULL));
 140         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(self);
 141
 142         /* for now create a local test-window */
 143
 144         data = NULL;
 145         edit_win = modest_ui_new_editor_window(ui, &data);
 146
 147         if (!edit_win)
 148                 return NULL;
 149         if (!data)
 150                 g_message("editor window user data is emtpy");
 151
 152         MODEST_EDITOR_WINDOW(self)->window = edit_win;
 153         priv->user_data = data;
 154
 155         return self;
 156 }
 157
 158 /*
 159  * return user defined data from a ModestEditorWindow instance
 160  * like e.g. a refernce to a GladeXML*
 161  */
 162 gpointer modest_editor_window_get_data(ModestEditorWindow *edit_win)
 163 {
 164         ModestEditorWindowPrivate *priv;
 165
 166         if (!edit_win) {
 167                 return NULL;
 168         }
 169         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 170
 171         // g_message("get priv->data = %p", priv->user_data);
 172
 173         return priv->user_data;
 174 }
 175
 176 gboolean modest_editor_window_set_modified(ModestEditorWindow *edit_win, gboolean modified)
 177 {
 178         ModestEditorWindowPrivate *priv;
 179
 180         if (!edit_win) {
 181                 return FALSE;
 182         }
 183         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 184
 185         priv->modified = modified;
 186
 187         return priv->modified;
 188 }
 189
 190 gboolean modest_editor_window_get_modified(ModestEditorWindow *edit_win)
 191 {
 192         ModestEditorWindowPrivate *priv;
 193
 194         if (!edit_win) {
 195                 return FALSE;
 196         }
 197         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 198
 199         // g_message("get priv->data = %p", priv->user_data);
 200
 201         return priv->modified;
 202 }
 203
 204 gboolean modest_editor_window_set_to_header(ModestEditorWindow *edit_win, const gchar *to)
 205 {
 206         ModestEditorWindowPrivate *priv;
 207
 208
 209         if (!edit_win)
 210                 return FALSE;
 211         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 212
 213         return modest_ui_editor_window_set_to_header(to, priv->user_data);
 214 }
 215
 216
 217 gboolean modest_editor_window_set_cc_header(ModestEditorWindow *edit_win, const gchar *cc)
 218 {
 219         ModestEditorWindowPrivate *priv;
 220
 221         if (!edit_win)
 222                 return FALSE;
 223
 224         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 225
 226         return modest_ui_editor_window_set_cc_header(cc, priv->user_data);
 227 }
 228
 229 gboolean modest_editor_window_set_bcc_header(ModestEditorWindow *edit_win, const gchar *bcc)
 230 {
 231         ModestEditorWindowPrivate *priv;
 232
 233         if (!edit_win)
 234                 return FALSE;
 235         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 236
 237         return modest_ui_editor_window_set_bcc_header(bcc, priv->user_data);
 238 }
 239
 240 gboolean modest_editor_window_set_subject_header(ModestEditorWindow *edit_win, const gchar *subject)
 241 {
 242         ModestEditorWindowPrivate *priv;
 243
 244         if (!edit_win)
 245                 return FALSE;
 246         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 247
 248         return modest_ui_editor_window_set_subject_header(subject, priv->user_data);
 249 }
 250
 251 gboolean modest_editor_window_set_body(ModestEditorWindow *edit_win, const gchar *body)
 252 {
 253         ModestEditorWindowPrivate *priv;
 254
 255         if (!edit_win)
 256                 return FALSE;
 257         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 258
 259         return modest_ui_editor_window_set_body(body, priv->user_data);
 260 }
 261
 262
 263 gboolean modest_editor_window_attach_file(ModestEditorWindow *edit_win,
 264                                           ModestTnyAttachment *attachment)
 265 {
 266         ModestEditorWindowPrivate *priv;
 267
 268         if (!edit_win)
 269                 return FALSE;
 270         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 271
 272         priv->attachments = g_list_append(priv->attachments,
 273                                           attachment);
 274
 275         return modest_ui_editor_window_update_attachments(priv->user_data);
 276 }
 277
 278 GList * modest_editor_window_set_attachments(ModestEditorWindow *edit_win, const GList* attachments)
 279 {
 280         ModestEditorWindowPrivate *priv;
 281         GList *pos;
 282
 283         g_return_val_if_fail(edit_win, NULL);
 284
 285         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 286
 287         modest_tny_attachment_free_list(priv->attachments);
 288         priv->attachments = g_list_copy((GList *)attachments);
 289         for (pos = priv->attachments ; pos ; pos = pos->next )
 290                 g_object_ref(pos->data);
 291
 292         return priv->attachments;
 293 }
 294
 295 GList * modest_editor_window_get_attachments(ModestEditorWindow *edit_win)
 296 {
 297         ModestEditorWindowPrivate *priv;
 298
 299         g_return_val_if_fail(edit_win, NULL);
 300
 301         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 302         return priv->attachments;
 303 }
 304
 305
 306 void
 307 modest_editor_window_set_identity(ModestEditorWindow *edit_win, const gchar *identity)
 308 {
 309         ModestEditorWindowPrivate *priv;
 310
 311         g_return_if_fail(edit_win);
 312
 313         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 314
 315         g_free(priv->identity);
 316         priv->identity = g_strdup(identity);
 317 }
 318
 319
 320 const gchar *
 321 modest_editor_window_get_identity(ModestEditorWindow *edit_win)
 322 {
 323         ModestEditorWindowPrivate *priv;
 324
 325         g_return_val_if_fail(edit_win, NULL);
 326
 327         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 328
 329         return priv->identity;
 330 }
 331
 332
 333 void
 334 modest_editor_window_set_transport(ModestEditorWindow *edit_win, const gchar *transport)
 335 {
 336         ModestEditorWindowPrivate *priv;
 337
 338         g_return_if_fail(edit_win);
 339
 340         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 341
 342         g_free(priv->transport);
 343         priv->transport = g_strdup(transport);
 344 }
 345
 346
 347 const gchar *
 348 modest_editor_window_get_transport(ModestEditorWindow *edit_win)
 349 {
 350         ModestEditorWindowPrivate *priv;
 351
 352         g_return_val_if_fail(edit_win, NULL);
 353
 354         priv = MODEST_EDITOR_WINDOW_GET_PRIVATE(edit_win);
 355
 356         return priv->transport;
 357 }