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