git.maemo.org Git - modest/blob - src/widgets/modest-attachments-view.c

   1 /* Copyright (c) 2007, 2009, 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 <config.h>
  31
  32 #include <string.h>
  33 #include <gtk/gtk.h>
  34 #include <gdk/gdkkeysyms.h>
  35 #include <tny-list.h>
  36 #include <tny-simple-list.h>
  37
  38 #include <modest-platform.h>
  39 #include <modest-runtime.h>
  40 #include <modest-attachment-view.h>
  41 #include <modest-attachments-view.h>
  42 #include <modest-tny-mime-part.h>
  43 #include <modest-tny-msg.h>
  44
  45 static GObjectClass *parent_class = NULL;
  46
  47 /* signals */
  48 enum {
  49         ACTIVATE_SIGNAL,
  50         DELETE_SIGNAL,
  51         LAST_SIGNAL
  52 };
  53
  54 typedef struct _ModestAttachmentsViewPrivate ModestAttachmentsViewPrivate;
  55
  56 struct _ModestAttachmentsViewPrivate
  57 {
  58         TnyMsg *msg;
  59         GtkWidget *box;
  60         GList *selected;
  61         GtkWidget *rubber_start;
  62         GtkWidget *press_att_view;
  63         GtkWidget *previous_selection;
  64         ModestAttachmentsViewStyle style;
  65 };
  66
  67 #define MODEST_ATTACHMENTS_VIEW_GET_PRIVATE(o)  \
  68         (G_TYPE_INSTANCE_GET_PRIVATE ((o), MODEST_TYPE_ATTACHMENTS_VIEW, ModestAttachmentsViewPrivate))
  69
  70 static gboolean button_press_event (GtkWidget *widget, GdkEventButton *event, ModestAttachmentsView *atts_view);
  71 static gboolean motion_notify_event (GtkWidget *widget, GdkEventMotion *event, ModestAttachmentsView *atts_view);
  72 static gboolean button_release_event (GtkWidget *widget, GdkEventButton *event, ModestAttachmentsView *atts_view);
  73 static gboolean key_press_event (GtkWidget *widget, GdkEventKey *event, ModestAttachmentsView *atts_view);
  74 static gboolean focus_out_event (GtkWidget *widget, GdkEventFocus *event, ModestAttachmentsView *atts_view);
  75 static gboolean focus (GtkWidget *widget, GtkDirectionType direction, ModestAttachmentsView *atts_view);
  76 static GtkWidget *get_att_view_at_coords (ModestAttachmentsView *atts_view,
  77                                           gdouble x, gdouble y);
  78 static void unselect_all (ModestAttachmentsView *atts_view);
  79 static void set_selected (ModestAttachmentsView *atts_view, ModestAttachmentView *att_view);
  80 static void select_range (ModestAttachmentsView *atts_view, ModestAttachmentView *att1, ModestAttachmentView *att2);
  81 static void clipboard_get (GtkClipboard *clipboard, GtkSelectionData *selection_data,
  82                            guint info, gpointer userdata);
  83 static void own_clipboard (ModestAttachmentsView *atts_view);
  84
  85 static guint signals[LAST_SIGNAL] = {0};
  86
  87 /**
  88  * modest_attachments_view_new:
  89  * @msg: a #TnyMsg
  90  *
  91  * Constructor for attachments view widget.
  92  *
  93  * Return value: a new #ModestAttachmentsView instance implemented for Gtk+
  94  **/
  95 GtkWidget*
  96 modest_attachments_view_new (TnyMsg *msg)
  97 {
  98         ModestAttachmentsView *self = g_object_new (MODEST_TYPE_ATTACHMENTS_VIEW,
  99                                                     "resize-mode", GTK_RESIZE_PARENT,
 100                                                     NULL);
 101
 102         modest_attachments_view_set_message (self, msg);
 103
 104         return GTK_WIDGET (self);
 105 }
 106
 107 static void
 108 add_digest_attachments (ModestAttachmentsView *attachments_view, TnyMimePart *part)
 109 {
 110         TnyList *parts;
 111         TnyIterator *iter;
 112
 113         parts = TNY_LIST (tny_simple_list_new());
 114         tny_mime_part_get_parts (TNY_MIME_PART (part), parts);
 115
 116         for (iter  = tny_list_create_iterator(parts);
 117              !tny_iterator_is_done (iter);
 118              tny_iterator_next (iter)) {
 119                 TnyMimePart *cur_part = TNY_MIME_PART (tny_iterator_get_current (iter));
 120                 modest_attachments_view_add_attachment (attachments_view, cur_part, TRUE, 0);
 121                 g_object_unref (cur_part);
 122         }
 123         g_object_unref (iter);
 124         g_object_unref (parts);
 125
 126 }
 127
 128
 129 void
 130 modest_attachments_view_set_message (ModestAttachmentsView *attachments_view, TnyMsg *msg)
 131 {
 132         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (attachments_view);
 133         TnyList *parts;
 134         TnyIterator *iter;
 135         gchar *msg_content_type = NULL;
 136         TnyMimePart *part_to_check;
 137         gboolean body_found;
 138         gboolean is_alternate;
 139
 140         if (msg == priv->msg) return;
 141
 142         if (priv->msg)
 143                 g_object_unref (priv->msg);
 144         if (msg)
 145                 g_object_ref (G_OBJECT(msg));
 146
 147         priv->msg = msg;
 148
 149         g_list_free (priv->selected);
 150         priv->selected = NULL;
 151
 152         gtk_container_foreach (GTK_CONTAINER (priv->box), (GtkCallback) gtk_widget_destroy, NULL);
 153
 154         if (priv->msg == NULL)
 155                 return;
 156
 157         part_to_check = modest_tny_msg_get_attachments_parent (TNY_MSG (msg));
 158         msg_content_type = modest_tny_mime_part_get_content_type (TNY_MIME_PART (part_to_check));
 159         is_alternate = !strcasecmp (msg_content_type, "multipart/alternative");
 160
 161         /* If the top mime part is a multipart/related, we don't show the attachments, as they're
 162          * embedded images in body */
 163         if ((msg_content_type != NULL) && !strcasecmp (msg_content_type, "multipart/related")) {
 164                 gchar *header_content_type;
 165                 gboolean application_multipart = FALSE;
 166
 167                 g_free (msg_content_type);
 168
 169                 header_content_type = modest_tny_mime_part_get_headers_content_type (TNY_MIME_PART (part_to_check));
 170
 171                 if ((header_content_type != NULL) &&
 172                     !strstr (header_content_type, "application/")) {
 173                         application_multipart = TRUE;
 174                 }
 175                 g_free (header_content_type);
 176
 177                 if (application_multipart) {
 178                         gtk_widget_queue_draw (GTK_WIDGET (attachments_view));
 179                         g_object_unref (part_to_check);
 180                         return;
 181                 }
 182         } else {
 183                 gboolean direct_attach;
 184
 185                 direct_attach = (!g_str_has_prefix (msg_content_type, "message/rfc822") &&
 186                                  !g_str_has_prefix (msg_content_type, "multipart") &&
 187                                  !g_str_has_prefix (msg_content_type, "text/"));
 188
 189                 g_free (msg_content_type);
 190
 191                 if (direct_attach) {
 192                         modest_attachments_view_add_attachment (attachments_view, TNY_MIME_PART (part_to_check), TRUE, 0);
 193                         gtk_widget_queue_draw (GTK_WIDGET (attachments_view));
 194                         g_object_unref (part_to_check);
 195                         return;
 196                 }
 197         }
 198
 199         parts = TNY_LIST (tny_simple_list_new ());
 200         tny_mime_part_get_parts (TNY_MIME_PART (part_to_check), parts);
 201         iter = tny_list_create_iterator (parts);
 202
 203         body_found = FALSE;
 204         while (!tny_iterator_is_done (iter)) {
 205                 TnyMimePart *part;
 206                 gchar *content_type;
 207
 208                 part = TNY_MIME_PART (tny_iterator_get_current (iter));
 209
 210                 if (part && (modest_tny_mime_part_is_attachment_for_modest (part))) {
 211                         modest_attachments_view_add_attachment (attachments_view, part, TRUE, 0);
 212
 213                 } else if (part && !is_alternate) {
 214                         content_type = g_ascii_strdown (tny_mime_part_get_content_type (part), -1);
 215                         g_strstrip (content_type);
 216
 217                         if (g_str_has_prefix (content_type, "multipart/digest")) {
 218                                 add_digest_attachments (attachments_view, part);
 219                         } else if (body_found && g_str_has_prefix (content_type, "text/")) {
 220                                    modest_attachments_view_add_attachment (attachments_view, part, TRUE, 0);
 221                         } else if (g_str_has_prefix (content_type, "multipart/") ||
 222                                    g_str_has_prefix (content_type, "text/")) {
 223                                 body_found = TRUE;
 224                         }
 225                 }
 226
 227
 228                 if (part)
 229                         g_object_unref (part);
 230
 231                 tny_iterator_next (iter);
 232         }
 233         g_object_unref (iter);
 234         g_object_unref (parts);
 235         g_object_unref (part_to_check);
 236
 237         gtk_widget_queue_draw (GTK_WIDGET (attachments_view));
 238
 239 }
 240
 241 void
 242 modest_attachments_view_add_attachment (ModestAttachmentsView *attachments_view, TnyMimePart *part,
 243                                         gboolean detect_size, guint64 size)
 244 {
 245         GtkWidget *att_view = NULL;
 246         ModestAttachmentsViewPrivate *priv = NULL;
 247
 248         g_return_if_fail (MODEST_IS_ATTACHMENTS_VIEW (attachments_view));
 249         g_return_if_fail (TNY_IS_MIME_PART (part));
 250
 251         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (attachments_view);
 252
 253         att_view = modest_attachment_view_new (part, detect_size);
 254         if (!detect_size)
 255                 modest_attachment_view_set_size (MODEST_ATTACHMENT_VIEW (att_view), size);
 256         gtk_box_pack_start (GTK_BOX (priv->box), att_view, FALSE, FALSE, 0);
 257         gtk_widget_show_all (att_view);
 258         gtk_widget_queue_resize (GTK_WIDGET (attachments_view));
 259 }
 260
 261 void
 262 modest_attachments_view_remove_attachment (ModestAttachmentsView *atts_view, TnyMimePart *mime_part)
 263 {
 264         ModestAttachmentsViewPrivate *priv = NULL;
 265         GList *box_children = NULL, *node = NULL;
 266         ModestAttachmentView *found_att_view = NULL;
 267
 268         g_return_if_fail (MODEST_IS_ATTACHMENTS_VIEW (atts_view));
 269         g_return_if_fail (TNY_IS_MIME_PART (mime_part));
 270
 271         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 272         box_children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 273
 274         for (node = box_children; node != NULL; node = g_list_next (node)) {
 275                 ModestAttachmentView *att_view = (ModestAttachmentView *) node->data;
 276                 TnyMimePart *cur_mime_part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 277
 278                 if (mime_part == cur_mime_part)
 279                         found_att_view = att_view;
 280
 281                 g_object_unref (cur_mime_part);
 282
 283                 if (found_att_view != NULL)
 284                         break;
 285         }
 286
 287         if (found_att_view) {
 288                 GList *node = NULL;
 289                 GtkWidget *next_widget = NULL;
 290                 GList *box_children = NULL;
 291
 292                 box_children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 293                 node = g_list_find (box_children, found_att_view);
 294                 if (node && node->next)
 295                         next_widget = node->next->data;
 296
 297                 g_list_free (box_children);
 298                 gtk_widget_destroy (GTK_WIDGET (found_att_view));
 299
 300                 node = g_list_find (priv->selected, found_att_view);
 301                 if (node) {
 302                         priv->selected = g_list_delete_link (priv->selected, node);
 303                         if ((priv->selected == NULL) && (next_widget != NULL))
 304                                 set_selected (MODEST_ATTACHMENTS_VIEW (atts_view),
 305                                               MODEST_ATTACHMENT_VIEW (next_widget));
 306                 }
 307                 own_clipboard (atts_view);
 308
 309         }
 310
 311         gtk_widget_queue_resize (GTK_WIDGET (atts_view));
 312 }
 313
 314 void
 315 modest_attachments_view_remove_attachment_by_id (ModestAttachmentsView *atts_view, const gchar *att_id)
 316 {
 317         ModestAttachmentsViewPrivate *priv = NULL;
 318         GList *box_children = NULL, *node = NULL;
 319
 320         g_return_if_fail (MODEST_IS_ATTACHMENTS_VIEW (atts_view));
 321         g_return_if_fail (att_id != NULL);
 322
 323         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 324         box_children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 325
 326         for (node = box_children; node != NULL; node = g_list_next (node)) {
 327                 ModestAttachmentView *att_view = (ModestAttachmentView *) node->data;
 328                 TnyMimePart *cur_mime_part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 329                 const gchar *mime_part_id = NULL;
 330
 331                 mime_part_id = tny_mime_part_get_content_id (cur_mime_part);
 332                 if ((mime_part_id != NULL) && (strcmp (mime_part_id, att_id) == 0)) {
 333                         gtk_widget_destroy (GTK_WIDGET (att_view));
 334                         priv->selected = g_list_remove (priv->selected, att_view);
 335                 }
 336
 337                 g_object_unref (cur_mime_part);
 338         }
 339
 340         own_clipboard (atts_view);
 341
 342         gtk_widget_queue_resize (GTK_WIDGET (atts_view));
 343 }
 344
 345 static void
 346 modest_attachments_view_instance_init (GTypeInstance *instance, gpointer g_class)
 347 {
 348         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (instance);
 349
 350         priv->msg = NULL;
 351         priv->box = gtk_vbox_new (FALSE, 0);
 352         priv->rubber_start = NULL;
 353         priv->press_att_view = NULL;
 354         priv->selected = NULL;
 355         priv->style = MODEST_ATTACHMENTS_VIEW_STYLE_SELECTABLE;
 356
 357         gtk_container_add (GTK_CONTAINER (instance), priv->box);
 358         gtk_event_box_set_above_child (GTK_EVENT_BOX (instance), TRUE);
 359
 360         g_signal_connect (G_OBJECT (instance), "button-press-event", G_CALLBACK (button_press_event), instance);
 361         g_signal_connect (G_OBJECT (instance), "button-release-event", G_CALLBACK (button_release_event), instance);
 362         g_signal_connect (G_OBJECT (instance), "motion-notify-event", G_CALLBACK (motion_notify_event), instance);
 363         g_signal_connect (G_OBJECT (instance), "key-press-event", G_CALLBACK (key_press_event), instance);
 364         g_signal_connect (G_OBJECT (instance), "focus-out-event", G_CALLBACK (focus_out_event), instance);
 365         g_signal_connect (G_OBJECT (instance), "focus", G_CALLBACK (focus), instance);
 366
 367         GTK_WIDGET_SET_FLAGS (instance, GTK_CAN_FOCUS);
 368
 369         return;
 370 }
 371
 372 static void
 373 modest_attachments_view_finalize (GObject *object)
 374 {
 375         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (object);
 376
 377         if (priv->msg) {
 378                 g_object_unref (priv->msg);
 379                 priv->msg = NULL;
 380         }
 381
 382         (*parent_class->finalize) (object);
 383
 384         return;
 385 }
 386
 387 static void
 388 modest_attachments_view_class_init (ModestAttachmentsViewClass *klass)
 389 {
 390         GObjectClass *object_class;
 391         GtkWidgetClass *widget_class;
 392
 393         parent_class = g_type_class_peek_parent (klass);
 394         object_class = (GObjectClass*) klass;
 395         widget_class = GTK_WIDGET_CLASS (klass);
 396
 397         object_class->finalize = modest_attachments_view_finalize;
 398
 399         klass->activate = NULL;
 400
 401         g_type_class_add_private (object_class, sizeof (ModestAttachmentsViewPrivate));
 402
 403         signals[ACTIVATE_SIGNAL] =
 404                 g_signal_new ("activate",
 405                               G_TYPE_FROM_CLASS (object_class),
 406                               G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 407                               G_STRUCT_OFFSET(ModestAttachmentsViewClass, activate),
 408                               NULL, NULL,
 409                               g_cclosure_marshal_VOID__OBJECT,
 410                               G_TYPE_NONE, 1, G_TYPE_OBJECT);
 411
 412         signals[DELETE_SIGNAL] =
 413                 g_signal_new ("delete",
 414                               G_TYPE_FROM_CLASS (object_class),
 415                               G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 416                               G_STRUCT_OFFSET(ModestAttachmentsViewClass, delete),
 417                               NULL, NULL,
 418                               g_cclosure_marshal_VOID__VOID,
 419                               G_TYPE_NONE, 0);
 420
 421         return;
 422 }
 423
 424 GType
 425 modest_attachments_view_get_type (void)
 426 {
 427         static GType type = 0;
 428
 429         if (G_UNLIKELY(type == 0))
 430         {
 431                 static const GTypeInfo info =
 432                 {
 433                   sizeof (ModestAttachmentsViewClass),
 434                   NULL,   /* base_init */
 435                   NULL,   /* base_finalize */
 436                   (GClassInitFunc) modest_attachments_view_class_init,   /* class_init */
 437                   NULL,   /* class_finalize */
 438                   NULL,   /* class_data */
 439                   sizeof (ModestAttachmentsView),
 440                   0,      /* n_preallocs */
 441                   modest_attachments_view_instance_init    /* instance_init */
 442                 };
 443
 444                 type = g_type_register_static (GTK_TYPE_EVENT_BOX,
 445                         "ModestAttachmentsView",
 446                         &info, 0);
 447
 448         }
 449
 450         return type;
 451 }
 452
 453 /* buttons signal events */
 454 static gboolean
 455 button_press_event (GtkWidget *widget,
 456                     GdkEventButton *event,
 457                     ModestAttachmentsView *atts_view)
 458 {
 459         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 460         if (priv->style == MODEST_ATTACHMENTS_VIEW_STYLE_SELECTABLE &&
 461             !GTK_WIDGET_HAS_FOCUS (widget))
 462                 gtk_widget_grab_focus (widget);
 463
 464         if (event->button == 1 && event->type == GDK_BUTTON_PRESS) {
 465                 GtkWidget *att_view = NULL;
 466
 467                 att_view = get_att_view_at_coords (MODEST_ATTACHMENTS_VIEW (widget),
 468                                                    (gint) event->x_root, (gint) event->y_root);
 469
 470                 if (att_view != NULL) {
 471                         if (priv->style == MODEST_ATTACHMENTS_VIEW_STYLE_NO_FOCUS) {
 472                                 unselect_all (MODEST_ATTACHMENTS_VIEW (widget));
 473                         } else if (priv->style == MODEST_ATTACHMENTS_VIEW_STYLE_LINKS) {
 474                                 priv->press_att_view = att_view;
 475                                 set_selected (MODEST_ATTACHMENTS_VIEW (widget), MODEST_ATTACHMENT_VIEW (att_view));
 476                                 gtk_grab_add (widget);
 477                         } else {
 478                                 if (g_list_length (priv->selected) == 1) {
 479                                         priv->previous_selection = GTK_WIDGET (priv->selected->data);
 480                                 } else {
 481                                         priv->previous_selection = NULL;
 482                                 }
 483                                 TnyMimePart *mime_part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 484
 485                                 /* Do not select purged attachments */
 486                                 if (TNY_IS_MIME_PART (mime_part) && !tny_mime_part_is_purged (mime_part)) {
 487                                         set_selected (MODEST_ATTACHMENTS_VIEW (widget), MODEST_ATTACHMENT_VIEW (att_view));
 488                                         priv->rubber_start = att_view;
 489                                         gtk_grab_add (widget);
 490                                 }
 491                                 g_object_unref (mime_part);
 492                         }
 493                 }
 494         }
 495         return TRUE;
 496
 497 }
 498
 499 static gboolean
 500 button_release_event (GtkWidget *widget,
 501                       GdkEventButton *event,
 502                       ModestAttachmentsView *atts_view)
 503 {
 504         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 505         if (widget == gtk_grab_get_current ()) {
 506                 GtkWidget *att_view = NULL;
 507
 508                 att_view = get_att_view_at_coords (MODEST_ATTACHMENTS_VIEW (widget),
 509                                                    (gint) event->x_root, (gint) event->y_root);
 510
 511                 if (priv->style == MODEST_ATTACHMENTS_VIEW_STYLE_LINKS) {
 512                         unselect_all (MODEST_ATTACHMENTS_VIEW (widget));
 513                         if (att_view == priv->press_att_view) {
 514                                 TnyMimePart *mime_part;
 515                                 mime_part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 516                                 g_signal_emit (G_OBJECT (widget), signals[ACTIVATE_SIGNAL], 0, mime_part);
 517                                 g_object_unref (mime_part);
 518                         }
 519                         priv->press_att_view = NULL;
 520                 } else {
 521
 522                         if (priv->style != MODEST_ATTACHMENTS_VIEW_STYLE_NO_FOCUS &&
 523                             priv->rubber_start == att_view  &&
 524                             priv->previous_selection == att_view) {
 525                                 TnyMimePart *mime_part;
 526                                 mime_part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 527                                 g_signal_emit (G_OBJECT (widget), signals[ACTIVATE_SIGNAL], 0, mime_part);
 528                                 g_object_unref (mime_part);
 529                         } else if (att_view != NULL) {
 530                                 unselect_all (MODEST_ATTACHMENTS_VIEW (widget));
 531                                 select_range (MODEST_ATTACHMENTS_VIEW (widget),
 532                                               MODEST_ATTACHMENT_VIEW (priv->rubber_start),
 533                                               MODEST_ATTACHMENT_VIEW (att_view));
 534                         }
 535                         priv->rubber_start = NULL;
 536                 }
 537                 gtk_grab_remove (widget);
 538         }
 539         return TRUE;
 540 }
 541
 542 static gboolean
 543 motion_notify_event (GtkWidget *widget,
 544                      GdkEventMotion *event,
 545                      ModestAttachmentsView *atts_view)
 546 {
 547         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 548         if (gtk_grab_get_current () == widget) {
 549                 GtkWidget *att_view = NULL;
 550
 551                 att_view = get_att_view_at_coords (MODEST_ATTACHMENTS_VIEW (widget),
 552                                                    (gint) event->x_root, (gint) event->y_root);
 553                 if (priv->style == MODEST_ATTACHMENTS_VIEW_STYLE_LINKS) {
 554                         if (att_view == priv->press_att_view) {
 555                                 if (priv->selected == NULL)
 556                                 set_selected (MODEST_ATTACHMENTS_VIEW (widget), MODEST_ATTACHMENT_VIEW (att_view));
 557                         } else {
 558                                 if (priv->selected) {
 559                                         unselect_all (MODEST_ATTACHMENTS_VIEW (widget));
 560                                 }
 561                         }
 562                 } else {
 563
 564                         if (att_view != NULL) {
 565                                 unselect_all (MODEST_ATTACHMENTS_VIEW (widget));
 566                                 select_range (MODEST_ATTACHMENTS_VIEW (widget),
 567                                               MODEST_ATTACHMENT_VIEW (priv->rubber_start),
 568                                               MODEST_ATTACHMENT_VIEW (att_view));
 569                         }
 570                 }
 571                 gdk_event_request_motions (event);
 572         }
 573         return TRUE;
 574 }
 575
 576 static GList*
 577 find_prev_or_next_not_purged (GList *list, gboolean prev, gboolean include_this)
 578 {
 579         GList *tmp = NULL;
 580         gboolean is_valid;
 581
 582         if (!include_this) {
 583                 if (prev) {
 584                         tmp = g_list_previous (list);
 585                 } else {
 586                         tmp = g_list_next (list);
 587                 }
 588         } else {
 589                 tmp = list;
 590         }
 591
 592         if (!tmp)
 593                 return NULL;
 594
 595         do {
 596                 ModestAttachmentView *att_view = (ModestAttachmentView *) tmp->data;
 597                 TnyMimePart *mime_part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 598
 599                 /* Do not select purged attachments */
 600                 if (TNY_IS_MIME_PART (mime_part) && !tny_mime_part_is_purged (mime_part)) {
 601                         is_valid = TRUE;
 602                 } else {
 603                         if (prev)
 604                                 tmp = g_list_previous (tmp);
 605                         else
 606                                 tmp = g_list_next (tmp);
 607                         is_valid = FALSE;
 608                 }
 609                 g_object_unref (mime_part);
 610         } while (!is_valid && tmp);
 611
 612         return tmp;
 613 }
 614
 615
 616 static gboolean
 617 key_press_event (GtkWidget *widget,
 618                  GdkEventKey *event,
 619                  ModestAttachmentsView *atts_view)
 620 {
 621         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 622
 623         if (priv->style == MODEST_ATTACHMENTS_VIEW_STYLE_NO_FOCUS) {
 624                 unselect_all (atts_view);
 625                 return FALSE;
 626         }
 627
 628         /* If grabbed (for example rubber banding), escape leaves the rubberbanding mode */
 629         if (gtk_grab_get_current () == widget) {
 630                 if (event->keyval == GDK_Escape) {
 631                         set_selected (MODEST_ATTACHMENTS_VIEW (widget),
 632                                       MODEST_ATTACHMENT_VIEW (priv->rubber_start));
 633                         priv->rubber_start = NULL;
 634                         gtk_grab_remove (widget);
 635                         return TRUE;
 636                 }
 637                 return FALSE;
 638         }
 639
 640         if (event->keyval == GDK_Up) {
 641                 ModestAttachmentView *current_sel = NULL;
 642                 gboolean move_out = FALSE;
 643                 GList * box_children, *new_sel, *first_child;
 644
 645                 box_children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 646                 if (box_children == NULL) {
 647                         move_out = TRUE;
 648                 } else {
 649                         first_child = box_children;
 650                         first_child = find_prev_or_next_not_purged (box_children, FALSE, TRUE);
 651                         if (priv->selected != NULL && first_child != NULL) {
 652                                 if (priv->selected->data != first_child->data)
 653                                         current_sel = (ModestAttachmentView *) priv->selected->data;
 654                                 else
 655                                         move_out = TRUE;
 656                         } else {
 657                                 move_out = TRUE;
 658                         }
 659                 }
 660
 661                 if (move_out) {
 662                         GtkWidget *toplevel = NULL;
 663                         /* move cursor outside */
 664                         toplevel = gtk_widget_get_toplevel (widget);
 665                         if (GTK_WIDGET_TOPLEVEL (toplevel) && GTK_IS_WINDOW (toplevel))
 666                                 g_signal_emit_by_name (toplevel, "move-focus", GTK_DIR_UP);
 667                         unselect_all (atts_view);
 668                 } else {
 669                         new_sel = g_list_find (box_children, (gpointer) current_sel);
 670                         new_sel = find_prev_or_next_not_purged (new_sel, TRUE, FALSE);
 671                         /* We assume that we detected properly that
 672                            there is a not purge attachment so we don't
 673                            need to check NULL */
 674                         set_selected (MODEST_ATTACHMENTS_VIEW (atts_view), MODEST_ATTACHMENT_VIEW (new_sel->data));
 675                 }
 676                 g_list_free (box_children);
 677                 return TRUE;
 678         }
 679
 680         if (event->keyval == GDK_Down) {
 681                 ModestAttachmentView *current_sel = NULL;
 682                 gboolean move_out = FALSE;
 683                 GList * box_children, *new_sel, *last_child = NULL;
 684
 685                 box_children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 686
 687                 if (box_children == NULL) {
 688                         move_out = TRUE;
 689                 } else {
 690                         last_child = g_list_last (box_children);
 691                         last_child = find_prev_or_next_not_purged (last_child, TRUE, TRUE);
 692                         if (priv->selected != NULL && last_child != NULL) {
 693                                 GList *last_selected = g_list_last (priv->selected);
 694                                 if (last_selected->data != last_child->data)
 695                                         current_sel = (ModestAttachmentView *) last_selected->data;
 696                                 else
 697                                         move_out = TRUE;
 698                         } else {
 699                                 move_out = TRUE;
 700                         }
 701                 }
 702
 703                 if (move_out) {
 704                         GtkWidget *toplevel = NULL;
 705                         /* move cursor outside */
 706                         toplevel = gtk_widget_get_toplevel (widget);
 707                         if (GTK_WIDGET_TOPLEVEL (toplevel) && GTK_IS_WINDOW (toplevel))
 708                                 g_signal_emit_by_name (toplevel, "move-focus", GTK_DIR_DOWN);
 709                         unselect_all (atts_view);
 710                 } else {
 711                         new_sel = g_list_find (box_children, (gpointer) current_sel);
 712                         new_sel = find_prev_or_next_not_purged (new_sel, FALSE, FALSE);
 713                         set_selected (MODEST_ATTACHMENTS_VIEW (atts_view), MODEST_ATTACHMENT_VIEW (new_sel->data));
 714                 }
 715                 g_list_free (box_children);
 716                 return TRUE;
 717         }
 718
 719         if (event->keyval == GDK_BackSpace) {
 720                 g_signal_emit (G_OBJECT (widget), signals[DELETE_SIGNAL], 0);
 721                 return TRUE;
 722         }
 723
 724         /* Activates selected item */
 725         if (g_list_length (priv->selected) == 1) {
 726                 ModestAttachmentView *att_view = (ModestAttachmentView *) priv->selected->data;
 727                 if ((event->keyval == GDK_Return)) {
 728                         TnyMimePart *mime_part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 729                         if (TNY_IS_MIME_PART (mime_part)) {
 730                                 g_signal_emit (G_OBJECT (widget), signals[ACTIVATE_SIGNAL], 0, mime_part);
 731                                 g_object_unref (mime_part);
 732                         }
 733                         return TRUE;
 734                 }
 735         }
 736
 737         return FALSE;
 738 }
 739
 740
 741 static GtkWidget *
 742 get_att_view_at_coords (ModestAttachmentsView *atts_view,
 743                         gdouble x, gdouble y)
 744 {
 745         ModestAttachmentsViewPrivate *priv = NULL;
 746         GList *att_view_list, *node;
 747         GtkWidget *result = NULL;
 748
 749         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 750         att_view_list = gtk_container_get_children (GTK_CONTAINER (priv->box));
 751
 752         for (node = att_view_list; node != NULL; node = g_list_next (node)) {
 753                 GtkWidget *att_view = (GtkWidget *) node->data;
 754                 gint pos_x, pos_y, w, h, int_x, int_y;
 755                 gint widget_x, widget_y;
 756
 757                 gdk_window_get_origin (att_view->window, &widget_x, &widget_y);
 758
 759                 pos_x = widget_x;
 760                 pos_y = widget_y;
 761                 w = att_view->allocation.width;
 762                 h = att_view->allocation.height;
 763
 764                 int_x = (gint) x - GTK_WIDGET (atts_view)->allocation.x;
 765                 int_y = (gint) y - GTK_WIDGET (atts_view)->allocation.y;
 766
 767                 if ((x >= pos_x) && (x <= (pos_x + w)) && (y >= pos_y) && (y <= (pos_y + h))) {
 768                         result = att_view;
 769                         break;
 770                 }
 771         }
 772
 773         g_list_free (att_view_list);
 774         return result;
 775 }
 776
 777 static void
 778 unselect_all (ModestAttachmentsView *atts_view)
 779 {
 780         ModestAttachmentsViewPrivate *priv = NULL;
 781         GList *att_view_list, *node;
 782
 783         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 784         att_view_list = gtk_container_get_children (GTK_CONTAINER (priv->box));
 785
 786         for (node = att_view_list; node != NULL; node = g_list_next (node)) {
 787                 GtkWidget *att_view = (GtkWidget *) node->data;
 788
 789                 if (GTK_WIDGET_STATE (att_view) == GTK_STATE_SELECTED)
 790                         gtk_widget_set_state (att_view, GTK_STATE_NORMAL);
 791         }
 792
 793         g_list_free (priv->selected);
 794         priv->selected = NULL;
 795
 796         g_list_free (att_view_list);
 797 }
 798
 799 static void
 800 set_selected (ModestAttachmentsView *atts_view, ModestAttachmentView *att_view)
 801 {
 802         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 803         TnyMimePart *part;
 804
 805         unselect_all (atts_view);
 806         part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 807
 808         g_list_free (priv->selected);
 809         priv->selected = NULL;
 810         if (TNY_IS_MIME_PART (part) && !tny_mime_part_is_purged (part)) {
 811                 gtk_widget_set_state (GTK_WIDGET (att_view), GTK_STATE_SELECTED);
 812                 priv->selected = g_list_append (priv->selected, att_view);
 813         }
 814         if (part)
 815                 g_object_unref (part);
 816
 817         own_clipboard (atts_view);
 818 }
 819
 820 static void
 821 select_range (ModestAttachmentsView *atts_view, ModestAttachmentView *att1, ModestAttachmentView *att2)
 822 {
 823         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 824         GList *children = NULL;
 825         GList *node = NULL;
 826         gboolean selecting = FALSE;
 827         TnyMimePart *part;
 828
 829         unselect_all (atts_view);
 830
 831         if (att1 == att2) {
 832                 set_selected (atts_view, att1);
 833                 return;
 834         }
 835
 836         children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 837         g_list_free (priv->selected);
 838         priv->selected = NULL;
 839
 840
 841         for (node = children; node != NULL; node = g_list_next (node)) {
 842                 if ((node->data == att1) || (node->data == att2)) {
 843                         part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (node->data));
 844                         if (!tny_mime_part_is_purged (part)) {
 845                                 gtk_widget_set_state (GTK_WIDGET (node->data), GTK_STATE_SELECTED);
 846                                 priv->selected = g_list_append (priv->selected, node->data);
 847                         }
 848                         g_object_unref (part);
 849                         selecting = !selecting;
 850                 } else if (selecting) {
 851                         part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (node->data));
 852                         if (!tny_mime_part_is_purged (part)) {
 853                                 gtk_widget_set_state (GTK_WIDGET (node->data), GTK_STATE_SELECTED);
 854                                 priv->selected = g_list_append (priv->selected, node->data);
 855                         }
 856                         g_object_unref (part);
 857                 }
 858
 859         }
 860         g_list_free (children);
 861
 862         own_clipboard (atts_view);
 863 }
 864
 865 static void clipboard_get (GtkClipboard *clipboard, GtkSelectionData *selection_data,
 866                            guint info, gpointer userdata)
 867 {
 868         ModestAttachmentsView *atts_view = (ModestAttachmentsView *) userdata;
 869         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 870
 871         if ((priv->selected != NULL)&&(priv->selected->next == NULL)) {
 872                 if (info == MODEST_ATTACHMENTS_VIEW_CLIPBOARD_TYPE_INDEX) {
 873                         /* MODEST_ATTACHMENT requested. As the content id is not filled in all the case, we'll
 874                          * use an internal index. This index is simply the index of the attachment in the vbox */
 875                         GList *box_children = NULL;
 876                         gint index;
 877                         box_children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 878                         index = g_list_index (box_children, priv->selected);
 879                         if (index >= 0) {
 880                                 gchar *index_str = g_strdup_printf("%d", index);
 881                                 gtk_selection_data_set_text (selection_data, index_str, -1);
 882                                 g_free (index_str);
 883                         }
 884                 }
 885         }
 886 }
 887
 888 TnyList *
 889 modest_attachments_view_get_selection (ModestAttachmentsView *atts_view)
 890 {
 891         ModestAttachmentsViewPrivate *priv;
 892         TnyList *selection;
 893         GList *node;
 894
 895         g_return_val_if_fail (MODEST_IS_ATTACHMENTS_VIEW (atts_view), NULL);
 896         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 897
 898         selection = tny_simple_list_new ();
 899         for (node = priv->selected; node != NULL; node = g_list_next (node)) {
 900                 ModestAttachmentView *att_view = (ModestAttachmentView *) node->data;
 901                 TnyMimePart *part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 902                 tny_list_append (selection, (GObject *) part);
 903                 g_object_unref (part);
 904         }
 905
 906         return selection;
 907 }
 908
 909 TnyList *
 910 modest_attachments_view_get_attachments (ModestAttachmentsView *atts_view)
 911 {
 912         ModestAttachmentsViewPrivate *priv;
 913         TnyList *att_list;
 914         GList *children, *node= NULL;
 915
 916         g_return_val_if_fail (MODEST_IS_ATTACHMENTS_VIEW (atts_view), NULL);
 917         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 918
 919         att_list = TNY_LIST (tny_simple_list_new ());
 920
 921         children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 922         for (node = children; node != NULL; node = g_list_next (node)) {
 923                 GtkWidget *att_view = GTK_WIDGET (node->data);
 924                 TnyMimePart *mime_part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 925                 tny_list_append (att_list, (GObject *) mime_part);
 926                 g_object_unref (mime_part);
 927         }
 928         g_list_free (children);
 929         return att_list;
 930
 931 }
 932
 933 void
 934 modest_attachments_view_select_all (ModestAttachmentsView *atts_view)
 935 {
 936         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 937         GList *children = NULL;
 938         GList *node = NULL;
 939
 940         unselect_all (atts_view);
 941
 942         if (priv->style == MODEST_ATTACHMENTS_VIEW_STYLE_LINKS)
 943                 return;
 944
 945         children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 946         g_list_free (priv->selected);
 947         priv->selected = NULL;
 948
 949         for (node = children; node != NULL; node = g_list_next (node)) {
 950                 ModestAttachmentView *att_view = (ModestAttachmentView *) node->data;
 951                 TnyMimePart *mime_part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
 952
 953                 /* Do not select purged attachments */
 954                 if (TNY_IS_MIME_PART (mime_part) && !tny_mime_part_is_purged (mime_part)) {
 955                         gtk_widget_set_state (GTK_WIDGET (node->data), GTK_STATE_SELECTED);
 956                         priv->selected = g_list_append (priv->selected, node->data);
 957                 }
 958                 g_object_unref (mime_part);
 959         }
 960         g_list_free (children);
 961
 962         own_clipboard (atts_view);
 963 }
 964
 965 gboolean
 966 modest_attachments_view_has_attachments (ModestAttachmentsView *atts_view)
 967 {
 968         ModestAttachmentsViewPrivate *priv;
 969         GList *children;
 970         gboolean result;
 971
 972         g_return_val_if_fail (MODEST_IS_ATTACHMENTS_VIEW (atts_view), FALSE);
 973         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
 974
 975         children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 976         result = (children != NULL);
 977         g_list_free (children);
 978
 979         return result;
 980 }
 981
 982 void
 983 modest_attachments_view_get_sizes (ModestAttachmentsView *attachments_view,
 984                                    gint *attachments_count,
 985                                    guint64 *attachments_size)
 986 {
 987         ModestAttachmentsViewPrivate *priv;
 988         GList *children, *node;
 989
 990         g_return_if_fail (MODEST_IS_ATTACHMENTS_VIEW (attachments_view));
 991         g_return_if_fail (attachments_count != NULL && attachments_size != NULL);
 992
 993         *attachments_count = 0;
 994         *attachments_size = 0;
 995
 996         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (attachments_view);
 997
 998         children = gtk_container_get_children (GTK_CONTAINER (priv->box));
 999         for (node = children; node != NULL; node = g_list_next (node)) {
1000                 GtkWidget *att_view = (GtkWidget *) node->data;
1001                 TnyMimePart *part = tny_mime_part_view_get_part (TNY_MIME_PART_VIEW (att_view));
1002
1003                 if (!tny_mime_part_is_purged (part)) {
1004                         guint64 size;
1005                         (*attachments_count) ++;
1006                         size = modest_attachment_view_get_size (MODEST_ATTACHMENT_VIEW (att_view));
1007                         if (size == 0) {
1008                                 /* we do a random estimation of the size of an attachment */
1009                                 size = 32768;
1010                         }
1011                         *attachments_size += size;
1012                 }
1013                 g_object_unref (part);
1014         }
1015         g_list_free (children);
1016 }
1017
1018 static void
1019 dummy_clear_func (GtkClipboard *clipboard,
1020                   gpointer user_data_or_owner)
1021 {
1022         /* Do nothing */
1023 }
1024
1025 static void
1026 own_clipboard (ModestAttachmentsView *atts_view)
1027 {
1028         GtkTargetEntry targets[] = {
1029                 {MODEST_ATTACHMENTS_VIEW_CLIPBOARD_TYPE, 0, MODEST_ATTACHMENTS_VIEW_CLIPBOARD_TYPE_INDEX},
1030         };
1031
1032         gtk_clipboard_set_with_owner (gtk_widget_get_clipboard (GTK_WIDGET (atts_view), GDK_SELECTION_PRIMARY),
1033                                       targets, G_N_ELEMENTS (targets),
1034                                       clipboard_get, dummy_clear_func, G_OBJECT(atts_view));
1035 }
1036
1037 static gboolean
1038 focus_out_event (GtkWidget *widget, GdkEventFocus *event, ModestAttachmentsView *atts_view)
1039 {
1040         if (!gtk_widget_is_focus (widget))
1041                 unselect_all (atts_view);
1042
1043         return FALSE;
1044 }
1045
1046 static gboolean
1047 focus (GtkWidget *widget, GtkDirectionType direction, ModestAttachmentsView *atts_view)
1048 {
1049         ModestAttachmentsViewPrivate *priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
1050         GList *children = NULL;
1051         GtkWidget *toplevel = NULL;
1052
1053         toplevel = gtk_widget_get_toplevel (widget);
1054         if (!gtk_window_has_toplevel_focus (GTK_WINDOW (toplevel)))
1055                 return FALSE;
1056
1057         if (priv->style != MODEST_ATTACHMENTS_VIEW_STYLE_NO_FOCUS) {
1058                 children = gtk_container_get_children (GTK_CONTAINER (priv->box));
1059                 if (children != NULL) {
1060                         set_selected (atts_view, MODEST_ATTACHMENT_VIEW (children->data));
1061                 }
1062                 g_list_free (children);
1063         }
1064
1065         return FALSE;
1066 }
1067
1068 void
1069 modest_attachments_view_set_style (ModestAttachmentsView *self,
1070                                    ModestAttachmentsViewStyle style)
1071 {
1072         ModestAttachmentsViewPrivate *priv;
1073
1074         g_return_if_fail (MODEST_IS_ATTACHMENTS_VIEW (self));
1075         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (self);
1076
1077         if (priv->style != style) {
1078                 priv->style = style;
1079                 gtk_widget_queue_draw (GTK_WIDGET (self));
1080                 if (priv->style == MODEST_ATTACHMENTS_VIEW_STYLE_SELECTABLE) {
1081                         GTK_WIDGET_SET_FLAGS (self, GTK_CAN_FOCUS);
1082                 } else {
1083                         GTK_WIDGET_UNSET_FLAGS (self, GTK_CAN_FOCUS);
1084                 }
1085
1086         }
1087 }
1088
1089 guint
1090 modest_attachments_view_get_num_attachments (ModestAttachmentsView *atts_view)
1091 {
1092         ModestAttachmentsViewPrivate *priv;
1093         GList *children;
1094         gint result;
1095
1096         g_return_val_if_fail (MODEST_IS_ATTACHMENTS_VIEW (atts_view), 0);
1097         priv = MODEST_ATTACHMENTS_VIEW_GET_PRIVATE (atts_view);
1098
1099         children = gtk_container_get_children (GTK_CONTAINER (priv->box));
1100         result = g_list_length (children);
1101         g_list_free (children);
1102
1103         return result;
1104 }