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

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