e-util/e-selection.c

   1 /*
   2  * e-selection.c
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11  * for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  15  *
  16  *
  17  * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
  18  *
  19  */
  20
  21 /**
  22  * SECTION: e-selection
  23  * @short_description: selection and clipboard utilities
  24  * @include: e-util/e-util.h
  25  **/
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include <config.h>
  29 #endif
  30
  31 #include "e-selection.h"
  32
  33 #include <string.h>
  34
  35 typedef struct _RequestTextInfo RequestTextInfo;
  36 typedef struct _WaitForDataResults WaitForDataResults;
  37
  38 struct _RequestTextInfo {
  39         GtkClipboardTextReceivedFunc callback;
  40         gpointer user_data;
  41 };
  42
  43 struct _WaitForDataResults {
  44         GMainLoop *loop;
  45         gpointer data;
  46 };
  47
  48 enum {
  49         ATOM_CALENDAR,
  50         ATOM_X_VCALENDAR,
  51         NUM_CALENDAR_ATOMS
  52 };
  53
  54 enum {
  55         ATOM_DIRECTORY,
  56         ATOM_X_VCARD,
  57         NUM_DIRECTORY_ATOMS
  58 };
  59
  60 enum {
  61         ATOM_HTML,
  62         NUM_HTML_ATOMS
  63 };
  64
  65 static GdkAtom calendar_atoms[NUM_CALENDAR_ATOMS];
  66 static GdkAtom directory_atoms[NUM_DIRECTORY_ATOMS];
  67 static GdkAtom html_atoms[NUM_HTML_ATOMS];
  68
  69 static void
  70 init_atoms (void)
  71 {
  72         static gboolean initialized = FALSE;
  73
  74         if (initialized)
  75                 return;
  76
  77         /* Calendar Atoms */
  78
  79         calendar_atoms[ATOM_CALENDAR] =
  80                 gdk_atom_intern_static_string ("text/calendar");
  81
  82         calendar_atoms[ATOM_X_VCALENDAR] =
  83                 gdk_atom_intern_static_string ("text/x-vcalendar");
  84
  85         /* Directory Atoms */
  86
  87         directory_atoms[ATOM_DIRECTORY] =
  88                 gdk_atom_intern_static_string ("text/directory");
  89
  90         directory_atoms[ATOM_X_VCARD] =
  91                 gdk_atom_intern_static_string ("text/x-vcard");
  92
  93         /* HTML Atoms */
  94
  95         html_atoms[ATOM_HTML] =
  96                 gdk_atom_intern_static_string ("text/html");
  97
  98         initialized = TRUE;
  99 }
 100
 101 static void
 102 clipboard_wait_for_text_cb (GtkClipboard *clipboard,
 103                             const gchar *source,
 104                             WaitForDataResults *results)
 105 {
 106         results->data = g_strdup (source);
 107         g_main_loop_quit (results->loop);
 108 }
 109
 110 void
 111 e_target_list_add_calendar_targets (GtkTargetList *list,
 112                                     guint info)
 113 {
 114         gint ii;
 115
 116         g_return_if_fail (list != NULL);
 117
 118         init_atoms ();
 119
 120         for (ii = 0; ii < NUM_CALENDAR_ATOMS; ii++)
 121                 gtk_target_list_add (list, calendar_atoms[ii], 0, info);
 122 }
 123
 124 void
 125 e_target_list_add_directory_targets (GtkTargetList *list,
 126                                      guint info)
 127 {
 128         gint ii;
 129
 130         g_return_if_fail (list != NULL);
 131
 132         init_atoms ();
 133
 134         for (ii = 0; ii < NUM_DIRECTORY_ATOMS; ii++)
 135                 gtk_target_list_add (list, directory_atoms[ii], 0, info);
 136 }
 137
 138 void
 139 e_target_list_add_html_targets (GtkTargetList *list,
 140                                 guint info)
 141 {
 142         gint ii;
 143
 144         g_return_if_fail (list != NULL);
 145
 146         init_atoms ();
 147
 148         for (ii = 0; ii < NUM_HTML_ATOMS; ii++)
 149                 gtk_target_list_add (list, html_atoms[ii], 0, info);
 150 }
 151
 152 gboolean
 153 e_selection_data_set_calendar (GtkSelectionData *selection_data,
 154                                const gchar *source,
 155                                gint length)
 156 {
 157         GdkAtom atom;
 158         gint ii;
 159
 160         g_return_val_if_fail (selection_data != NULL, FALSE);
 161         g_return_val_if_fail (source != NULL, FALSE);
 162
 163         if (length < 0)
 164                 length = strlen (source);
 165
 166         init_atoms ();
 167
 168         atom = gtk_selection_data_get_target (selection_data);
 169
 170         /* All calendar atoms are treated the same. */
 171         for (ii = 0; ii < NUM_CALENDAR_ATOMS; ii++) {
 172                 if (atom == calendar_atoms[ii]) {
 173                         gtk_selection_data_set (
 174                                 selection_data, atom, 8,
 175                                 (guchar *) source, length);
 176                         return TRUE;
 177                 }
 178         }
 179
 180         return FALSE;
 181 }
 182
 183 gboolean
 184 e_selection_data_set_directory (GtkSelectionData *selection_data,
 185                                 const gchar *source,
 186                                 gint length)
 187 {
 188         GdkAtom atom;
 189         gint ii;
 190
 191         g_return_val_if_fail (selection_data != NULL, FALSE);
 192         g_return_val_if_fail (source != NULL, FALSE);
 193
 194         if (length < 0)
 195                 length = strlen (source);
 196
 197         init_atoms ();
 198
 199         atom = gtk_selection_data_get_target (selection_data);
 200
 201         /* All directory atoms are treated the same. */
 202         for (ii = 0; ii < NUM_DIRECTORY_ATOMS; ii++) {
 203                 if (atom == directory_atoms[ii]) {
 204                         gtk_selection_data_set (
 205                                 selection_data, atom, 8,
 206                                 (guchar *) source, length);
 207                         return TRUE;
 208                 }
 209         }
 210
 211         return FALSE;
 212 }
 213
 214 gboolean
 215 e_selection_data_set_html (GtkSelectionData *selection_data,
 216                            const gchar *source,
 217                            gint length)
 218 {
 219         GdkAtom atom;
 220         gint ii;
 221
 222         g_return_val_if_fail (selection_data != NULL, FALSE);
 223         g_return_val_if_fail (source != NULL, FALSE);
 224
 225         if (length < 0)
 226                 length = strlen (source);
 227
 228         init_atoms ();
 229
 230         atom = gtk_selection_data_get_target (selection_data);
 231
 232         /* All HTML atoms are treated the same. */
 233         for (ii = 0; ii < NUM_HTML_ATOMS; ii++) {
 234                 if (atom == html_atoms[ii]) {
 235                         gtk_selection_data_set (
 236                                 selection_data, atom, 8,
 237                                 (guchar *) source, length);
 238                         return TRUE;
 239                 }
 240         }
 241
 242         return FALSE;
 243 }
 244
 245 gchar *
 246 e_selection_data_get_calendar (GtkSelectionData *selection_data)
 247 {
 248         GdkAtom data_type;
 249         const guchar *data = NULL;
 250         gint ii;
 251
 252         /* XXX May need to do encoding and line ending conversions
 253          *     here.  Not worrying about it for now. */
 254
 255         g_return_val_if_fail (selection_data != NULL, NULL);
 256
 257         data = gtk_selection_data_get_data (selection_data);
 258         data_type = gtk_selection_data_get_data_type (selection_data);
 259
 260         /* All calendar atoms are treated the same. */
 261         for (ii = 0; ii < NUM_CALENDAR_ATOMS; ii++)
 262                 if (data_type == calendar_atoms[ii])
 263                         return g_strdup ((gchar *) data);
 264
 265         return NULL;
 266 }
 267
 268 gchar *
 269 e_selection_data_get_directory (GtkSelectionData *selection_data)
 270 {
 271         GdkAtom data_type;
 272         const guchar *data = NULL;
 273         gint ii;
 274
 275         /* XXX May need to do encoding and line ending conversions
 276          *     here.  Not worrying about it for now. */
 277
 278         g_return_val_if_fail (selection_data != NULL, NULL);
 279
 280         data = gtk_selection_data_get_data (selection_data);
 281         data_type = gtk_selection_data_get_data_type (selection_data);
 282
 283         /* All directory atoms are treated the same. */
 284         for (ii = 0; ii < NUM_DIRECTORY_ATOMS; ii++)
 285                 if (data_type == directory_atoms[ii])
 286                         return g_strdup ((gchar *) data);
 287
 288         return NULL;
 289 }
 290
 291 gchar *
 292 e_selection_data_get_html (GtkSelectionData *selection_data)
 293 {
 294         GdkAtom data_type;
 295         const guchar *data = NULL;
 296         gchar *utf8_text;
 297         gint length;
 298         gint ii;
 299         GError *error = NULL;
 300
 301         /* XXX May need to do encoding conversions here.
 302          *     Not worrying about it for now. */
 303
 304         g_return_val_if_fail (selection_data != NULL, NULL);
 305
 306         data = gtk_selection_data_get_data (selection_data);
 307         length = gtk_selection_data_get_length (selection_data);
 308         data_type = gtk_selection_data_get_data_type (selection_data);
 309
 310         g_return_val_if_fail (data != NULL, NULL);
 311
 312         /* First validate the data.  Assume it's UTF-8 or UTF-16. */
 313         if (g_utf8_validate ((const gchar *) data, length - 1, NULL))
 314                 utf8_text = g_strdup ((const gchar *) data);
 315         else
 316                 utf8_text = g_convert (
 317                         (const gchar *) data, length,
 318                         "UTF-8", "UTF-16", NULL, NULL, &error);
 319
 320         if (error != NULL) {
 321                 g_warning ("%s", error->message);
 322                 g_error_free (error);
 323         }
 324
 325         /* All HTML atoms are treated the same. */
 326         for (ii = 0; ii < NUM_HTML_ATOMS; ii++)
 327                 if (data_type == html_atoms[ii])
 328                         return utf8_text;
 329
 330         g_free (utf8_text);
 331
 332         return NULL;
 333 }
 334
 335 gboolean
 336 e_selection_data_targets_include_calendar (GtkSelectionData *selection_data)
 337 {
 338         GdkAtom *targets;
 339         gint n_targets;
 340         gboolean result = FALSE;
 341
 342         g_return_val_if_fail (selection_data != NULL, FALSE);
 343
 344         if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets)) {
 345                 result = e_targets_include_calendar (targets, n_targets);
 346                 g_free (targets);
 347         }
 348
 349         return result;
 350 }
 351
 352 gboolean
 353 e_selection_data_targets_include_directory (GtkSelectionData *selection_data)
 354 {
 355         GdkAtom *targets;
 356         gint n_targets;
 357         gboolean result = FALSE;
 358
 359         g_return_val_if_fail (selection_data != NULL, FALSE);
 360
 361         if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets)) {
 362                 result = e_targets_include_directory (targets, n_targets);
 363                 g_free (targets);
 364         }
 365
 366         return result;
 367 }
 368
 369 gboolean
 370 e_selection_data_targets_include_html (GtkSelectionData *selection_data)
 371 {
 372         GdkAtom *targets;
 373         gint n_targets;
 374         gboolean result = FALSE;
 375
 376         g_return_val_if_fail (selection_data != NULL, FALSE);
 377
 378         if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets)) {
 379                 result = e_targets_include_html (targets, n_targets);
 380                 g_free (targets);
 381         }
 382
 383         return result;
 384 }
 385
 386 gboolean
 387 e_targets_include_calendar (GdkAtom *targets,
 388                             gint n_targets)
 389 {
 390         gint ii, jj;
 391
 392         g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
 393
 394         init_atoms ();
 395
 396         for (ii = 0; ii < n_targets; ii++)
 397                 for (jj = 0; jj < NUM_CALENDAR_ATOMS; jj++)
 398                         if (targets[ii] == calendar_atoms[jj])
 399                                 return TRUE;
 400
 401         return FALSE;
 402 }
 403
 404 gboolean
 405 e_targets_include_directory (GdkAtom *targets,
 406                              gint n_targets)
 407 {
 408         gint ii, jj;
 409
 410         g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
 411
 412         init_atoms ();
 413
 414         for (ii = 0; ii < n_targets; ii++)
 415                 for (jj = 0; jj < NUM_DIRECTORY_ATOMS; jj++)
 416                         if (targets[ii] == directory_atoms[jj])
 417                                 return TRUE;
 418
 419         return FALSE;
 420 }
 421
 422 gboolean
 423 e_targets_include_html (GdkAtom *targets,
 424                         gint n_targets)
 425 {
 426         gint ii, jj;
 427
 428         g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
 429
 430         init_atoms ();
 431
 432         for (ii = 0; ii < n_targets; ii++)
 433                 for (jj = 0; jj < NUM_HTML_ATOMS; jj++)
 434                         if (targets[ii] == html_atoms[jj])
 435                                 return TRUE;
 436
 437         return FALSE;
 438 }
 439
 440 static void
 441 clipboard_get_calendar (GtkClipboard *clipboard,
 442                         GtkSelectionData *selection_data,
 443                         guint info,
 444                         gchar *source)
 445 {
 446         e_selection_data_set_calendar (selection_data, source, -1);
 447 }
 448
 449 static void
 450 clipboard_clear_calendar (GtkClipboard *clipboard,
 451                           gchar *source)
 452 {
 453         g_free (source);
 454 }
 455
 456 void
 457 e_clipboard_set_calendar (GtkClipboard *clipboard,
 458                           const gchar *source,
 459                           gint length)
 460 {
 461         GtkTargetList *list;
 462         GtkTargetEntry *targets;
 463         gint n_targets;
 464
 465         g_return_if_fail (clipboard != NULL);
 466         g_return_if_fail (source != NULL);
 467
 468         list = gtk_target_list_new (NULL, 0);
 469         e_target_list_add_calendar_targets (list, 0);
 470
 471         targets = gtk_target_table_new_from_list (list, &n_targets);
 472
 473         if (length < 0)
 474                 length = strlen (source);
 475
 476         gtk_clipboard_set_with_data (
 477                 clipboard, targets, n_targets,
 478                 (GtkClipboardGetFunc) clipboard_get_calendar,
 479                 (GtkClipboardClearFunc) clipboard_clear_calendar,
 480                 g_strndup (source, length));
 481
 482         gtk_clipboard_set_can_store (clipboard, NULL, 0);
 483
 484         gtk_target_table_free (targets, n_targets);
 485         gtk_target_list_unref (list);
 486 }
 487
 488 static void
 489 clipboard_get_directory (GtkClipboard *clipboard,
 490                          GtkSelectionData *selection_data,
 491                          guint info,
 492                          gchar *source)
 493 {
 494         e_selection_data_set_directory (selection_data, source, -1);
 495 }
 496
 497 static void
 498 clipboard_clear_directory (GtkClipboard *clipboard,
 499                            gchar *source)
 500 {
 501         g_free (source);
 502 }
 503
 504 void
 505 e_clipboard_set_directory (GtkClipboard *clipboard,
 506                            const gchar *source,
 507                            gint length)
 508 {
 509         GtkTargetList *list;
 510         GtkTargetEntry *targets;
 511         gint n_targets;
 512
 513         g_return_if_fail (clipboard != NULL);
 514         g_return_if_fail (source != NULL);
 515
 516         list = gtk_target_list_new (NULL, 0);
 517         e_target_list_add_directory_targets (list, 0);
 518
 519         targets = gtk_target_table_new_from_list (list, &n_targets);
 520
 521         if (length < 0)
 522                 length = strlen (source);
 523
 524         gtk_clipboard_set_with_data (
 525                 clipboard, targets, n_targets,
 526                 (GtkClipboardGetFunc) clipboard_get_directory,
 527                 (GtkClipboardClearFunc) clipboard_clear_directory,
 528                 g_strndup (source, length));
 529
 530         gtk_clipboard_set_can_store (clipboard, NULL, 0);
 531
 532         gtk_target_table_free (targets, n_targets);
 533         gtk_target_list_unref (list);
 534 }
 535
 536 static void
 537 clipboard_get_html (GtkClipboard *clipboard,
 538                     GtkSelectionData *selection_data,
 539                     guint info,
 540                     gchar *source)
 541 {
 542         e_selection_data_set_html (selection_data, source, -1);
 543 }
 544
 545 static void
 546 clipboard_clear_html (GtkClipboard *clipboard,
 547                       gchar *source)
 548 {
 549         g_free (source);
 550 }
 551
 552 void
 553 e_clipboard_set_html (GtkClipboard *clipboard,
 554                       const gchar *source,
 555                       gint length)
 556 {
 557         GtkTargetList *list;
 558         GtkTargetEntry *targets;
 559         gint n_targets;
 560
 561         g_return_if_fail (clipboard != NULL);
 562         g_return_if_fail (source != NULL);
 563
 564         list = gtk_target_list_new (NULL, 0);
 565         e_target_list_add_html_targets (list, 0);
 566
 567         targets = gtk_target_table_new_from_list (list, &n_targets);
 568
 569         if (length < 0)
 570                 length = strlen (source);
 571
 572         gtk_clipboard_set_with_data (
 573                 clipboard, targets, n_targets,
 574                 (GtkClipboardGetFunc) clipboard_get_html,
 575                 (GtkClipboardClearFunc) clipboard_clear_html,
 576                 g_strndup (source, length));
 577
 578         gtk_clipboard_set_can_store (clipboard, NULL, 0);
 579
 580         gtk_target_table_free (targets, n_targets);
 581         gtk_target_list_unref (list);
 582 }
 583
 584 static void
 585 clipboard_request_calendar_cb (GtkClipboard *clipboard,
 586                                GtkSelectionData *selection_data,
 587                                RequestTextInfo *info)
 588 {
 589         gchar *source;
 590
 591         source = e_selection_data_get_calendar (selection_data);
 592         info->callback (clipboard, source, info->user_data);
 593         g_free (source);
 594
 595         g_slice_free (RequestTextInfo, info);
 596 }
 597
 598 void
 599 e_clipboard_request_calendar (GtkClipboard *clipboard,
 600                               GtkClipboardTextReceivedFunc callback,
 601                               gpointer user_data)
 602 {
 603         RequestTextInfo *info;
 604
 605         g_return_if_fail (clipboard != NULL);
 606         g_return_if_fail (callback != NULL);
 607
 608         init_atoms ();
 609
 610         info = g_slice_new (RequestTextInfo);
 611         info->callback = callback;
 612         info->user_data = user_data;
 613
 614         gtk_clipboard_request_contents (
 615                 clipboard, calendar_atoms[ATOM_CALENDAR],
 616                 (GtkClipboardReceivedFunc)
 617                 clipboard_request_calendar_cb, info);
 618 }
 619
 620 static void
 621 clipboard_request_directory_cb (GtkClipboard *clipboard,
 622                                 GtkSelectionData *selection_data,
 623                                 RequestTextInfo *info)
 624 {
 625         gchar *source;
 626
 627         source = e_selection_data_get_directory (selection_data);
 628         info->callback (clipboard, source, info->user_data);
 629         g_free (source);
 630
 631         g_slice_free (RequestTextInfo, info);
 632 }
 633
 634 void
 635 e_clipboard_request_directory (GtkClipboard *clipboard,
 636                                GtkClipboardTextReceivedFunc callback,
 637                                gpointer user_data)
 638 {
 639         RequestTextInfo *info;
 640
 641         g_return_if_fail (clipboard != NULL);
 642         g_return_if_fail (callback != NULL);
 643
 644         init_atoms ();
 645
 646         info = g_slice_new (RequestTextInfo);
 647         info->callback = callback;
 648         info->user_data = user_data;
 649
 650         gtk_clipboard_request_contents (
 651                 clipboard, directory_atoms[ATOM_DIRECTORY],
 652                 (GtkClipboardReceivedFunc)
 653                 clipboard_request_directory_cb, info);
 654 }
 655
 656 static void
 657 clipboard_request_html_cb (GtkClipboard *clipboard,
 658                            GtkSelectionData *selection_data,
 659                            RequestTextInfo *info)
 660 {
 661         gchar *source;
 662
 663         source = e_selection_data_get_html (selection_data);
 664         info->callback (clipboard, source, info->user_data);
 665         g_free (source);
 666
 667         g_slice_free (RequestTextInfo, info);
 668 }
 669
 670 void
 671 e_clipboard_request_html (GtkClipboard *clipboard,
 672                           GtkClipboardTextReceivedFunc callback,
 673                           gpointer user_data)
 674 {
 675         RequestTextInfo *info;
 676
 677         g_return_if_fail (clipboard != NULL);
 678         g_return_if_fail (callback != NULL);
 679
 680         init_atoms ();
 681
 682         info = g_slice_new (RequestTextInfo);
 683         info->callback = callback;
 684         info->user_data = user_data;
 685
 686         gtk_clipboard_request_contents (
 687                 clipboard, html_atoms[ATOM_HTML],
 688                 (GtkClipboardReceivedFunc)
 689                 clipboard_request_html_cb, info);
 690 }
 691
 692 gchar *
 693 e_clipboard_wait_for_calendar (GtkClipboard *clipboard)
 694 {
 695         WaitForDataResults results;
 696
 697         g_return_val_if_fail (clipboard != NULL, NULL);
 698
 699         results.data = NULL;
 700         results.loop = g_main_loop_new (NULL, TRUE);
 701
 702         e_clipboard_request_calendar (
 703                 clipboard, (GtkClipboardTextReceivedFunc)
 704                 clipboard_wait_for_text_cb, &results);
 705
 706         if (g_main_loop_is_running (results.loop))
 707                 g_main_loop_run (results.loop);
 708
 709         g_main_loop_unref (results.loop);
 710
 711         return results.data;
 712 }
 713
 714 gchar *
 715 e_clipboard_wait_for_directory (GtkClipboard *clipboard)
 716 {
 717         WaitForDataResults results;
 718
 719         g_return_val_if_fail (clipboard != NULL, NULL);
 720
 721         results.data = NULL;
 722         results.loop = g_main_loop_new (NULL, TRUE);
 723
 724         e_clipboard_request_directory (
 725                 clipboard, (GtkClipboardTextReceivedFunc)
 726                 clipboard_wait_for_text_cb, &results);
 727
 728         if (g_main_loop_is_running (results.loop))
 729                 g_main_loop_run (results.loop);
 730
 731         g_main_loop_unref (results.loop);
 732
 733         return results.data;
 734 }
 735
 736 gchar *
 737 e_clipboard_wait_for_html (GtkClipboard *clipboard)
 738 {
 739         WaitForDataResults results;
 740
 741         g_return_val_if_fail (clipboard != NULL, NULL);
 742
 743         results.data = NULL;
 744         results.loop = g_main_loop_new (NULL, TRUE);
 745
 746         e_clipboard_request_html (
 747                 clipboard, (GtkClipboardTextReceivedFunc)
 748                 clipboard_wait_for_text_cb, &results);
 749
 750         if (g_main_loop_is_running (results.loop))
 751                 g_main_loop_run (results.loop);
 752
 753         g_main_loop_unref (results.loop);
 754
 755         return results.data;
 756 }
 757
 758 gboolean
 759 e_clipboard_wait_is_calendar_available (GtkClipboard *clipboard)
 760 {
 761         GdkAtom *targets;
 762         gint n_targets;
 763         gboolean result = FALSE;
 764
 765         if (gtk_clipboard_wait_for_targets (clipboard, &targets, &n_targets)) {
 766                 result = e_targets_include_calendar (targets, n_targets);
 767                 g_free (targets);
 768         }
 769
 770         return result;
 771 }
 772
 773 gboolean
 774 e_clipboard_wait_is_directory_available (GtkClipboard *clipboard)
 775 {
 776         GdkAtom *targets;
 777         gint n_targets;
 778         gboolean result = FALSE;
 779
 780         if (gtk_clipboard_wait_for_targets (clipboard, &targets, &n_targets)) {
 781                 result = e_targets_include_directory (targets, n_targets);
 782                 g_free (targets);
 783         }
 784
 785         return result;
 786 }
 787
 788 gboolean
 789 e_clipboard_wait_is_html_available (GtkClipboard *clipboard)
 790 {
 791         GdkAtom *targets;
 792         gint n_targets;
 793         gboolean result = FALSE;
 794
 795         if (gtk_clipboard_wait_for_targets (clipboard, &targets, &n_targets)) {
 796                 result = e_targets_include_html (targets, n_targets);
 797                 g_free (targets);
 798         }
 799
 800         return result;
 801 }
 802
 803 void
 804 e_drag_dest_add_calendar_targets (GtkWidget *widget)
 805 {
 806         GtkTargetList *target_list;
 807
 808         g_return_if_fail (GTK_IS_WIDGET (widget));
 809
 810         target_list = gtk_drag_dest_get_target_list (widget);
 811         if (target_list != NULL)
 812                 gtk_target_list_ref (target_list);
 813         else
 814                 target_list = gtk_target_list_new (NULL, 0);
 815         e_target_list_add_calendar_targets (target_list, 0);
 816         gtk_drag_dest_set_target_list (widget, target_list);
 817         gtk_target_list_unref (target_list);
 818 }
 819
 820 void
 821 e_drag_dest_add_directory_targets (GtkWidget *widget)
 822 {
 823         GtkTargetList *target_list;
 824
 825         g_return_if_fail (GTK_IS_WIDGET (widget));
 826
 827         target_list = gtk_drag_dest_get_target_list (widget);
 828         if (target_list != NULL)
 829                 gtk_target_list_ref (target_list);
 830         else
 831                 target_list = gtk_target_list_new (NULL, 0);
 832         e_target_list_add_directory_targets (target_list, 0);
 833         gtk_drag_dest_set_target_list (widget, target_list);
 834         gtk_target_list_unref (target_list);
 835 }
 836
 837 void
 838 e_drag_dest_add_html_targets (GtkWidget *widget)
 839 {
 840         GtkTargetList *target_list;
 841
 842         g_return_if_fail (GTK_IS_WIDGET (widget));
 843
 844         target_list = gtk_drag_dest_get_target_list (widget);
 845         if (target_list != NULL)
 846                 gtk_target_list_ref (target_list);
 847         else
 848                 target_list = gtk_target_list_new (NULL, 0);
 849         e_target_list_add_html_targets (target_list, 0);
 850         gtk_drag_dest_set_target_list (widget, target_list);
 851         gtk_target_list_unref (target_list);
 852 }
 853
 854 void
 855 e_drag_source_add_calendar_targets (GtkWidget *widget)
 856 {
 857         GtkTargetList *target_list;
 858
 859         g_return_if_fail (GTK_IS_WIDGET (widget));
 860
 861         target_list = gtk_drag_source_get_target_list (widget);
 862         if (target_list != NULL)
 863                 gtk_target_list_ref (target_list);
 864         else
 865                 target_list = gtk_target_list_new (NULL, 0);
 866         e_target_list_add_calendar_targets (target_list, 0);
 867         gtk_drag_source_set_target_list (widget, target_list);
 868         gtk_target_list_unref (target_list);
 869 }
 870
 871 void
 872 e_drag_source_add_directory_targets (GtkWidget *widget)
 873 {
 874         GtkTargetList *target_list;
 875
 876         g_return_if_fail (GTK_IS_WIDGET (widget));
 877
 878         target_list = gtk_drag_source_get_target_list (widget);
 879         if (target_list != NULL)
 880                 gtk_target_list_ref (target_list);
 881         else
 882                 target_list = gtk_target_list_new (NULL, 0);
 883         e_target_list_add_directory_targets (target_list, 0);
 884         gtk_drag_source_set_target_list (widget, target_list);
 885         gtk_target_list_unref (target_list);
 886 }
 887
 888 void
 889 e_drag_source_add_html_targets (GtkWidget *widget)
 890 {
 891         GtkTargetList *target_list;
 892
 893         g_return_if_fail (GTK_IS_WIDGET (widget));
 894
 895         target_list = gtk_drag_source_get_target_list (widget);
 896         if (target_list != NULL)
 897                 gtk_target_list_ref (target_list);
 898         else
 899                 target_list = gtk_target_list_new (NULL, 0);
 900         e_target_list_add_html_targets (target_list, 0);
 901         gtk_drag_source_set_target_list (widget, target_list);
 902         gtk_target_list_unref (target_list);
 903 }