git.maemo.org Git - modest/blob - src/modest-email-clipboard.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-email-clipboard.h>
  31 #include <modest-tny-folder.h>
  32
  33 /* 'private'/'protected' functions */
  34 static void modest_email_clipboard_class_init (ModestEmailClipboardClass * klass);
  35 static void modest_email_clipboard_init       (ModestEmailClipboard * obj);
  36 static void modest_email_clipboard_finalize   (GObject * obj);
  37
  38 /* globals */
  39 static GObjectClass *parent_class = NULL;
  40
  41 typedef struct _ModestEmailClipboardPrivate ModestEmailClipboardPrivate;
  42 struct _ModestEmailClipboardPrivate {
  43         TnyList    *selection;
  44         TnyFolder  *src;
  45         gchar      **hidding;
  46         gboolean   delete;
  47 };
  48
  49
  50 #define MODEST_EMAIL_CLIPBOARD_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  51                                                 MODEST_TYPE_EMAIL_CLIPBOARD, \
  52                                                 ModestEmailClipboardPrivate))
  53
  54
  55 GType
  56 modest_email_clipboard_get_type (void)
  57 {
  58         static GType my_type = 0;
  59
  60         if (!my_type) {
  61                 static const GTypeInfo my_info = {
  62                         sizeof (ModestEmailClipboardClass),
  63                         NULL,   /* base init */
  64                         NULL,   /* base finalize */
  65                         (GClassInitFunc) modest_email_clipboard_class_init,
  66                         NULL,   /* class finalize */
  67                         NULL,   /* class data */
  68                         sizeof (ModestEmailClipboard),
  69                         1,      /* n_preallocs */
  70                         (GInstanceInitFunc) modest_email_clipboard_init,
  71                         NULL
  72                 };
  73
  74                 my_type = g_type_register_static (G_TYPE_OBJECT,
  75                                                   "ModestEmailClipboard",
  76                                                   &my_info, 0);
  77         }
  78         return my_type;
  79 }
  80
  81
  82
  83 static void
  84 modest_email_clipboard_class_init (ModestEmailClipboardClass * klass)
  85 {
  86         GObjectClass *gobject_class;
  87         gobject_class = (GObjectClass *) klass;
  88
  89         parent_class = g_type_class_peek_parent (klass);
  90         gobject_class->finalize = modest_email_clipboard_finalize;
  91
  92         g_type_class_add_private (gobject_class,
  93                                   sizeof (ModestEmailClipboardPrivate));
  94
  95         /* signal definitions */
  96 }
  97
  98
  99 static void
 100 modest_email_clipboard_init (ModestEmailClipboard * obj)
 101 {
 102         ModestEmailClipboardPrivate *priv =
 103                 MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (obj);
 104
 105         priv->src = NULL;
 106         priv->selection = NULL;
 107         priv->hidding = NULL;
 108         priv->delete = FALSE;
 109 }
 110
 111 static void
 112 modest_email_clipboard_finalize (GObject * obj)
 113 {
 114         /* Clear objects stored on clipboard */
 115         modest_email_clipboard_clear (MODEST_EMAIL_CLIPBOARD(obj));
 116
 117         G_OBJECT_CLASS(parent_class)->finalize (obj);
 118 }
 119
 120
 121 ModestEmailClipboard *
 122 modest_email_clipboard_new ()
 123 {
 124         GObject *obj;
 125         ModestEmailClipboardPrivate *priv;
 126
 127         obj = G_OBJECT (g_object_new (MODEST_TYPE_EMAIL_CLIPBOARD, NULL));
 128         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (obj);
 129
 130         return MODEST_EMAIL_CLIPBOARD (obj);
 131 }
 132
 133
 134 void
 135 modest_email_clipboard_get_data (ModestEmailClipboard *self,
 136                                  TnyFolder **src_folder,
 137                                  TnyList **data,
 138                                  gboolean *delete)
 139 {
 140         ModestEmailClipboardPrivate *priv = NULL;;
 141
 142         *src_folder = NULL;
 143         *data = NULL;
 144         *delete = FALSE;
 145
 146         g_return_if_fail (MODEST_IS_EMAIL_CLIPBOARD (self));
 147         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (self);
 148         g_return_if_fail (TNY_IS_FOLDER (priv->src));
 149
 150         /* if no data into clipboard, do nothing */
 151         if (modest_email_clipboard_cleared (self)) return;
 152
 153         /* Get data stored on clipboard */
 154         *src_folder = g_object_ref(priv->src);
 155         if (priv->selection)
 156                 *data = g_object_ref(priv->selection);
 157         *delete = priv->delete;
 158
 159         /* Clear objects stored on clipboard */
 160         modest_email_clipboard_clear (MODEST_EMAIL_CLIPBOARD(self));
 161 }
 162
 163 void
 164 modest_email_clipboard_set_data (ModestEmailClipboard *self,
 165                                  TnyFolder *src_folder,
 166                                  TnyList *data,
 167                                  gboolean delete)
 168 {
 169         ModestEmailClipboardPrivate *priv = NULL;;
 170         TnyIterator *iter = NULL;
 171         GObject *obj = NULL;
 172         gchar *id = NULL;
 173         guint i, n_selected;
 174
 175         g_return_if_fail (MODEST_IS_EMAIL_CLIPBOARD (self));
 176         g_return_if_fail (TNY_IS_FOLDER (src_folder));
 177         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (self);
 178
 179         /* if data into clipboard, clear them  */
 180         if (!modest_email_clipboard_cleared (self))
 181                 modest_email_clipboard_clear (self);
 182
 183         /* set new data */
 184         priv->src = g_object_ref (src_folder);
 185         if (data != NULL)
 186                 priv->selection = g_object_ref (data);
 187         priv->delete = delete;
 188         priv->hidding = NULL;
 189
 190         /* Fill hidding array (for cut operation) */
 191         if (delete) {
 192                 n_selected = 1;
 193                 if (data != NULL) {
 194                         n_selected = tny_list_get_length (data);
 195                         priv->hidding = g_malloc0(sizeof(gchar *) * n_selected);
 196                         iter = tny_list_create_iterator (priv->selection);
 197                         i = 0;
 198                         while (!tny_iterator_is_done (iter)) {
 199                                 obj = tny_iterator_get_current (iter);
 200                                 if (obj && TNY_IS_HEADER (obj))
 201                                         id = g_strdup(tny_header_get_message_id (TNY_HEADER (obj)));
 202
 203                                 priv->hidding[i++] = id;
 204                                 tny_iterator_next (iter);
 205
 206                                 if (obj)
 207                                         g_object_unref (obj);
 208                         }
 209                         g_object_unref (iter);
 210                 }
 211                 else {
 212                         priv->hidding = g_malloc0(sizeof(gchar *));
 213                         id = g_strdup (tny_folder_get_id (src_folder));
 214                         priv->hidding[0] = id;
 215                 }
 216         }
 217 }
 218
 219 void
 220 modest_email_clipboard_clear (ModestEmailClipboard *self)
 221 {
 222         ModestEmailClipboardPrivate *priv = NULL;
 223         guint i, n_selected;
 224
 225         g_return_if_fail (MODEST_IS_EMAIL_CLIPBOARD (self));
 226         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (self);
 227
 228         n_selected = 1;
 229         if (priv->src)
 230                 g_object_unref (priv->src);
 231         if (priv->selection) {
 232                 n_selected = tny_list_get_length(priv->selection);
 233                 g_object_unref (priv->selection);
 234         }
 235         if (priv->hidding) {
 236                 for (i=0; i < n_selected; i++)
 237                         g_free (priv->hidding[i]);
 238                 g_free(priv->hidding);
 239         }
 240
 241         priv->src = NULL;
 242         priv->selection = NULL;
 243         priv->hidding = NULL;
 244         priv->delete = FALSE;
 245 }
 246
 247 gboolean
 248 modest_email_clipboard_cleared (ModestEmailClipboard *self)
 249 {
 250         ModestEmailClipboardPrivate *priv = NULL;;
 251         gboolean cleared = FALSE;
 252
 253         g_return_val_if_fail (MODEST_IS_EMAIL_CLIPBOARD (self), TRUE);
 254         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (self);
 255
 256         cleared = ((priv->src == NULL) && (priv->selection == NULL));
 257
 258         return cleared;
 259 }
 260
 261 gboolean
 262 modest_email_clipboard_check_source_folder (ModestEmailClipboard *self,
 263                                             const TnyFolder *folder)
 264 {
 265         TnyFolderType folder_type1;
 266         TnyFolderType folder_type2;
 267         ModestEmailClipboardPrivate *priv = NULL;;
 268         const gchar *id1 = NULL;
 269         const gchar *id2 = NULL;
 270         gboolean same_folder = FALSE;
 271
 272         g_return_val_if_fail (MODEST_IS_EMAIL_CLIPBOARD (self), TRUE);
 273         g_return_val_if_fail (TNY_IS_FOLDER (folder), TRUE);
 274         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (self);
 275
 276         /* If cleared, return always FALSE*/
 277         if (modest_email_clipboard_cleared (self)) return FALSE;
 278
 279         /* Check target and source folders */
 280         id1 = tny_folder_get_id (priv->src);
 281         id2 = tny_folder_get_id (TNY_FOLDER(folder));
 282         folder_type1 = modest_tny_folder_guess_folder_type (priv->src);
 283         folder_type2 = modest_tny_folder_guess_folder_type (folder);
 284
 285         if (folder_type1 == TNY_FOLDER_TYPE_INVALID || folder_type2 == TNY_FOLDER_TYPE_INVALID)
 286                 g_warning ("%s: BUG: folder of type TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
 287
 288         same_folder = ((folder_type1 == folder_type2) &&
 289                        (!g_ascii_strcasecmp (id1, id2)));
 290
 291         return same_folder;
 292 }
 293
 294 gboolean
 295 modest_email_clipboard_headers_copied (ModestEmailClipboard *self)
 296 {
 297         ModestEmailClipboardPrivate *priv = NULL;;
 298         gboolean result = FALSE;
 299
 300         g_return_val_if_fail (MODEST_IS_EMAIL_CLIPBOARD (self), FALSE);
 301         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (self);
 302
 303         result = priv->selection != NULL;
 304
 305         return result;
 306 }
 307
 308 gboolean
 309 modest_email_clipboard_folder_copied (ModestEmailClipboard *self)
 310 {
 311         ModestEmailClipboardPrivate *priv = NULL;;
 312         gboolean result = FALSE;
 313
 314         g_return_val_if_fail (MODEST_IS_EMAIL_CLIPBOARD (self), FALSE);
 315         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (self);
 316
 317         result = ((priv->selection == NULL) && (priv->src != NULL));
 318
 319         return result;
 320 }
 321
 322 const gchar *
 323 modest_email_clipboard_get_folder_name (ModestEmailClipboard *self)
 324 {
 325         ModestEmailClipboardPrivate *priv = NULL;;
 326         const gchar *folder_name = NULL;
 327
 328         g_return_val_if_fail (MODEST_IS_EMAIL_CLIPBOARD (self), NULL);
 329         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (self);
 330
 331         /* If cleared, return always FALSE*/
 332         if (modest_email_clipboard_cleared (self)) return NULL;
 333
 334         /* Check target and source folders */
 335         folder_name = tny_folder_get_name (priv->src);
 336
 337         return folder_name;
 338 }
 339
 340 const gchar **
 341 modest_email_clipboard_get_hidding_ids (ModestEmailClipboard *self,
 342                                         guint *n_selected)
 343 {
 344         ModestEmailClipboardPrivate *priv = NULL;;
 345
 346         *n_selected = 0;
 347
 348         g_return_val_if_fail (MODEST_IS_EMAIL_CLIPBOARD (self), NULL);
 349         priv = MODEST_EMAIL_CLIPBOARD_GET_PRIVATE (self);
 350
 351         if (priv->selection != NULL)
 352                 *n_selected = tny_list_get_length (priv->selection);
 353         else
 354                 *n_selected = 1;
 355
 356         return (const gchar **) priv->hidding;
 357 }
 358