embed/ephy-embed-persist.c

   1 /*
   2  *  Copyright © 2000-2003 Marco Pesenti Gritti
   3  *  Copyright © 2003 Christian Persch
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  *  $Id: ephy-embed-persist.c 6952 2007-03-11 19:42:02Z chpe $
  20  */
  21
  22 #include "config.h"
  23
  24 #include "ephy-embed-persist.h"
  25 #include "mozilla-embed-persist.h"
  26 #include "ephy-embed-type-builtins.h"
  27 #include "ephy-debug.h"
  28
  29 #include <gtk/gtkmain.h>
  30
  31 enum
  32 {
  33         PROP_0,
  34         PROP_DEST,
  35         PROP_EMBED,
  36         PROP_FILECHOOSER_TITLE,
  37         PROP_FILECHOOSER_PARENT,
  38         PROP_FLAGS,
  39         PROP_HANDLER,
  40         PROP_MAX_SIZE,
  41         PROP_PERSISTKEY,
  42         PROP_SOURCE,
  43         PROP_USER_TIME
  44 };
  45
  46 #define EPHY_EMBED_PERSIST_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_EMBED_PERSIST, EphyEmbedPersistPrivate))
  47
  48 struct _EphyEmbedPersistPrivate
  49 {
  50         char *dest;
  51         char *source;
  52         char *fc_title;
  53         char *persist_key;
  54         EphyEmbed *embed;
  55         gint64 max_size;
  56         EphyEmbedPersistFlags flags;
  57         GtkWindow *fc_parent;
  58         guint32 user_time;
  59 };
  60
  61 static void     ephy_embed_persist_class_init   (EphyEmbedPersistClass *klass);
  62 static void     ephy_embed_persist_init         (EphyEmbedPersist *ges);
  63
  64 static GObjectClass *parent_class = NULL;
  65
  66 GType
  67 ephy_embed_persist_get_type (void)
  68 {
  69        static GType type = 0;
  70
  71         if (G_UNLIKELY (type == 0))
  72         {
  73                 const GTypeInfo our_info =
  74                 {
  75                         sizeof (EphyEmbedPersistClass),
  76                         NULL, /* base_init */
  77                         NULL, /* base_finalize */
  78                         (GClassInitFunc) ephy_embed_persist_class_init,
  79                         NULL, /* class_finalize */
  80                         NULL, /* class_data */
  81                         sizeof (EphyEmbedPersist),
  82                         0,    /* n_preallocs */
  83                         (GInstanceInitFunc) ephy_embed_persist_init
  84                 };
  85
  86                 type = g_type_register_static (G_TYPE_OBJECT,
  87                                                "EphyEmbedPersist",
  88                                                &our_info, G_TYPE_FLAG_ABSTRACT);
  89         }
  90
  91         return type;
  92 }
  93
  94 /**
  95  * ephy_embed_persist_set_dest:
  96  * @persist: an #EphyEmbedPersist
  97  * @value: the path to which @persist should save data
  98  *
  99  * Sets the path to which @persist should save data.
 100  **/
 101 void
 102 ephy_embed_persist_set_dest (EphyEmbedPersist *persist,
 103                              const char *value)
 104 {
 105         g_return_if_fail (EPHY_IS_EMBED_PERSIST (persist));
 106
 107         persist->priv->dest = g_strdup (value);
 108 }
 109
 110 /**
 111  * ephy_embed_persist_set_embed:
 112  * @persist: an #EphyEmbedPersist
 113  * @value: a parent #EphyEmbed
 114  *
 115  * Sets the #EphyEmbed from which @persist will download data.
 116  *
 117  * An #EphyEmbed is absolutely required to download if @persist's
 118  * #EphyEmbedPersistFlags include %EPHY_EMBED_PERSIST_COPY_PAGE. Regardless, an
 119  * #EphyEmbed should be set for <emphasis>every</emphasis> #EphyEmbedPersist,
 120  * since it determines request information such as the referring page.
 121  **/
 122 void
 123 ephy_embed_persist_set_embed (EphyEmbedPersist *persist,
 124                               EphyEmbed *value)
 125 {
 126         g_return_if_fail (EPHY_IS_EMBED_PERSIST (persist));
 127
 128         persist->priv->embed = value;
 129 }
 130
 131 /**
 132  * ephy_embed_persist_set_fc_title:
 133  * @persist: an #EphyEmbedPersist
 134  * @value: the title to be displayed by the filechooser
 135  *
 136  * Sets the title of the filechooser window. The filechooser will only be
 137  * displayed if %EPHY_EMBED_PERSIST_ASK_DESTINATION has been set with
 138  * ephy_embed_persist_set_flags().
 139  **/
 140 void
 141 ephy_embed_persist_set_fc_title (EphyEmbedPersist *persist,
 142                                  const char *value)
 143 {
 144         g_return_if_fail (EPHY_IS_EMBED_PERSIST (persist));
 145
 146         persist->priv->fc_title = g_strdup (value);
 147 }
 148
 149 /**
 150  * ephy_embed_persist_set_fc_parent:
 151  * @persist: an #EphyEmbedPersist
 152  * @value: the #EphyWindow which should be the filechooser's parent
 153  *
 154  * Sets the #EphyWindow which should be @persist's filechooser's parent. The
 155  * filechooser will only be displayed if %EPHY_EMBED_PERSIST_ASK_DESTINATION has been
 156  * set with ephy_embed_persist_set_flags().
 157  **/
 158 void
 159 ephy_embed_persist_set_fc_parent (EphyEmbedPersist *persist,
 160                                   GtkWindow *value)
 161 {
 162         EphyEmbedPersistPrivate *priv;
 163         GtkWindow **wptr;
 164
 165         g_return_if_fail (EPHY_IS_EMBED_PERSIST (persist));
 166
 167         priv = persist->priv;
 168
 169         priv->fc_parent = value;
 170         wptr = &priv->fc_parent;
 171         g_object_add_weak_pointer (G_OBJECT (priv->fc_parent),
 172                                    (gpointer *) wptr);
 173 }
 174
 175 /**
 176  * ephy_embed_persist_set_flags:
 177  * @persist: an #EphyEmbedPersist
 178  * @value: the desired #EphyEmbedPersistFlags
 179  *
 180  * Sets the flags to be used for @persist's download.
 181  **/
 182 void
 183 ephy_embed_persist_set_flags (EphyEmbedPersist *persist,
 184                               EphyEmbedPersistFlags value)
 185 {
 186         g_return_if_fail (EPHY_IS_EMBED_PERSIST (persist));
 187
 188         persist->priv->flags = value;
 189 }
 190
 191 /**
 192  * ephy_embed_persist_set_max_size:
 193  * @persist: an #EphyEmbedPersist
 194  * @value: maximum size of requested download, in bytes
 195  *
 196  * Sets the maximum size of @persist's download.
 197  *
 198  * If the requested file is discovered to be larger than @value, the download
 199  * will be aborted. Note that @persist will have to actually begin downloading
 200  * before it can abort, since it doesn't know the filesize before the download
 201  * starts.
 202  **/
 203 void
 204 ephy_embed_persist_set_max_size (EphyEmbedPersist *persist,
 205                                  gint64 value)
 206 {
 207         g_return_if_fail (EPHY_IS_EMBED_PERSIST (persist));
 208
 209         persist->priv->max_size = value;
 210 }
 211
 212 /**
 213  * ephy_embed_persist_set_persist_key:
 214  * @persist: an #EphyEmbedPersist
 215  * @value: a GConf key
 216  *
 217  * Sets the GConf key from which @persist will determine the default download
 218  * directory.
 219  **/
 220 void
 221 ephy_embed_persist_set_persist_key (EphyEmbedPersist *persist,
 222                                     const char *value)
 223 {
 224         g_return_if_fail (EPHY_IS_EMBED_PERSIST (persist));
 225
 226         persist->priv->persist_key = g_strdup (value);
 227 }
 228
 229 /**
 230  * ephy_embed_persist_set_source:
 231  * @persist: an #EphyEmbedPersist
 232  * @value: the URL from which @persist should download
 233  *
 234  * Sets the URL from which @persist should download. This should be used in
 235  * conjunction with ephy_embed_persist_set_embed().
 236  **/
 237 void
 238 ephy_embed_persist_set_source (EphyEmbedPersist *persist,
 239                                const char *value)
 240 {
 241         g_return_if_fail (EPHY_IS_EMBED_PERSIST (persist));
 242
 243         persist->priv->source = g_strdup (value);
 244 }
 245
 246 /**
 247  * ephy_embed_persist_set_user_time:
 248  * @persist: an #EphyEmbedPersist
 249  * @user_time: a timestamp, or 0
 250  *
 251  * Sets the time stamp of the user action which created @persist.
 252  * Defaults to gtk_get_current_event_time() when @persist is created.
 253  **/
 254 void
 255 ephy_embed_persist_set_user_time (EphyEmbedPersist *persist,
 256                                   guint32 user_time)
 257 {
 258         g_return_if_fail (EPHY_IS_EMBED_PERSIST (persist));
 259
 260         LOG ("ephy_embed_persist_set_user_time persist %p user-time %d",
 261              persist, user_time);
 262
 263         persist->priv->user_time = user_time;
 264 }
 265
 266 /**
 267  * ephy_embed_persist_get_dest:
 268  * @persist: an #EphyEmbedPersist
 269  *
 270  * Returns the destination filename to which @persist will save its download.
 271  *
 272  * Return value: @persist's destination filename
 273  **/
 274 const char *
 275 ephy_embed_persist_get_dest (EphyEmbedPersist *persist)
 276 {
 277         g_return_val_if_fail (EPHY_IS_EMBED_PERSIST (persist), NULL);
 278
 279         return persist->priv->dest;
 280 }
 281
 282 /**
 283  * ephy_embed_persist_get_embed:
 284  * @persist: an #EphyEmbedPersist
 285  *
 286  * Returns the #EphyEmbed from which @persist will download.
 287  *
 288  * Return value: the #EphyEmbed from which @persist will download
 289  **/
 290 EphyEmbed *
 291 ephy_embed_persist_get_embed (EphyEmbedPersist *persist)
 292 {
 293         g_return_val_if_fail (EPHY_IS_EMBED_PERSIST (persist), NULL);
 294
 295         return persist->priv->embed;
 296 }
 297
 298 /**
 299  * ephy_embed_persist_get_fc_title:
 300  * @persist: an #EphyEmbedPersist
 301  *
 302  * Returns the title to be displayed in @persist's filechooser.
 303  *
 304  * Return value: the title to be displayed in @persist's filechooser
 305  **/
 306 const char *
 307 ephy_embed_persist_get_fc_title (EphyEmbedPersist *persist)
 308 {
 309         g_return_val_if_fail (EPHY_IS_EMBED_PERSIST (persist), NULL);
 310
 311         return persist->priv->fc_title;
 312 }
 313
 314 /**
 315  * ephy_embed_persist_get_fc_parent:
 316  * @persist: an #EphyEmbedPersist
 317  *
 318  * Returns the #EphyWindow which should serve as a parent for @persist's
 319  * filechooser.
 320  *
 321  * Return value: the #EphyWindow parent for @persist's filechooser
 322  **/
 323 GtkWindow *
 324 ephy_embed_persist_get_fc_parent (EphyEmbedPersist *persist)
 325 {
 326         g_return_val_if_fail (EPHY_IS_EMBED_PERSIST (persist), NULL);
 327
 328         return persist->priv->fc_parent;
 329 }
 330
 331 /**
 332  * ephy_embed_persist_get_flags:
 333  * @persist: an #EphyEmbedPersist
 334  *
 335  * Returns @persist's #EphyEmbedPersistFlags.
 336  *
 337  * Return value: @persist's #EphyEmbedPersistFlags
 338  **/
 339 EphyEmbedPersistFlags
 340 ephy_embed_persist_get_flags (EphyEmbedPersist *persist)
 341 {
 342         g_return_val_if_fail (EPHY_IS_EMBED_PERSIST (persist), 0);
 343
 344         return persist->priv->flags;
 345 }
 346
 347 /**
 348  * ephy_embed_persist_get_max_size:
 349  * @persist: an #EphyEmbedPersist
 350  *
 351  * Returns the maximum size of @persist's requested download, in bytes.
 352  *
 353  * Return value: the maximum size of @persist's requested download, in bytes
 354  **/
 355 gint64
 356 ephy_embed_persist_get_max_size (EphyEmbedPersist *persist)
 357 {
 358         g_return_val_if_fail (EPHY_IS_EMBED_PERSIST (persist), 0);
 359
 360         return persist->priv->max_size;
 361 }
 362
 363 /**
 364  * ephy_embed_persist_get_persist_key:
 365  * @persist: an #EphyEmbedPersist
 366  *
 367  * Returns the GConf key which determines Epiphany's default download directory.
 368  *
 369  * Return value: the GConf key to the default download directory
 370  **/
 371 const char *
 372 ephy_embed_persist_get_persist_key (EphyEmbedPersist *persist)
 373 {
 374         g_return_val_if_fail (EPHY_IS_EMBED_PERSIST (persist), NULL);
 375
 376         return persist->priv->persist_key;
 377 }
 378
 379 /**
 380  * ephy_embed_persist_get_source:
 381  * @persist: an #EphyEmbedPersist
 382  *
 383  * Returns the source URL of the file to download.
 384  *
 385  * Return value: a source URL
 386  **/
 387 const char *
 388 ephy_embed_persist_get_source (EphyEmbedPersist *persist)
 389 {
 390         g_return_val_if_fail (EPHY_IS_EMBED_PERSIST (persist), NULL);
 391
 392         return persist->priv->source;
 393 }
 394
 395 /**
 396  * ephy_embed_persist_get_user_time:
 397  * @persist: an #EphyEmbedPersist
 398  *
 399  * Returns the timestamp of the user action which created @persist.
 400  * If not set explicitly, defaults to gtk_get_current_event_time ()
 401  * at the time of creation of @persist.
 402  *
 403  * Return value: a timestamp, or 0
 404  **/
 405 guint32
 406 ephy_embed_persist_get_user_time (EphyEmbedPersist *persist)
 407 {
 408         g_return_val_if_fail (EPHY_IS_EMBED_PERSIST (persist), 0);
 409
 410         return persist->priv->user_time;
 411 }
 412
 413 static void
 414 ephy_embed_persist_set_property (GObject *object,
 415                                  guint prop_id,
 416                                  const GValue *value,
 417                                  GParamSpec *pspec)
 418 {
 419         EphyEmbedPersist *persist = EPHY_EMBED_PERSIST (object);
 420
 421         switch (prop_id)
 422         {
 423                 case PROP_DEST:
 424                         ephy_embed_persist_set_dest (persist, g_value_get_string (value));
 425                         break;
 426                 case PROP_EMBED:
 427                         ephy_embed_persist_set_embed (persist, g_value_get_object (value));
 428                         break;
 429                 case PROP_FILECHOOSER_TITLE:
 430                         ephy_embed_persist_set_fc_title (persist, g_value_get_string (value));
 431                         break;
 432                 case PROP_FILECHOOSER_PARENT:
 433                         ephy_embed_persist_set_fc_parent (persist, g_value_get_object (value));
 434                         break;
 435                 case PROP_FLAGS:
 436                         ephy_embed_persist_set_flags (persist, g_value_get_flags (value));
 437                         break;
 438                 case PROP_MAX_SIZE:
 439                         ephy_embed_persist_set_max_size (persist, g_value_get_int64 (value));
 440                         break;
 441                 case PROP_PERSISTKEY:
 442                         ephy_embed_persist_set_persist_key (persist, g_value_get_string (value));
 443                         break;
 444                 case PROP_SOURCE:
 445                         ephy_embed_persist_set_source (persist, g_value_get_string (value));
 446                         break;
 447                 case PROP_USER_TIME:
 448                         ephy_embed_persist_set_user_time (persist, g_value_get_uint (value));
 449                         break;
 450         }
 451 }
 452
 453 static void
 454 ephy_embed_persist_get_property (GObject *object,
 455                                  guint prop_id,
 456                                  GValue *value,
 457                                  GParamSpec *pspec)
 458 {
 459         EphyEmbedPersist *persist = EPHY_EMBED_PERSIST (object);
 460
 461         switch (prop_id)
 462         {
 463                 case PROP_DEST:
 464                         g_value_set_string (value, ephy_embed_persist_get_dest (persist));
 465                         break;
 466                 case PROP_EMBED:
 467                         g_value_set_object (value, ephy_embed_persist_get_embed (persist));
 468                         break;
 469                 case PROP_FILECHOOSER_TITLE:
 470                         g_value_set_string (value, ephy_embed_persist_get_fc_title (persist));
 471                         break;
 472                 case PROP_FILECHOOSER_PARENT:
 473                         g_value_set_object (value, ephy_embed_persist_get_fc_parent (persist));
 474                         break;
 475                 case PROP_FLAGS:
 476                         g_value_set_flags (value, ephy_embed_persist_get_flags (persist));
 477                         break;
 478                 case PROP_MAX_SIZE:
 479                         g_value_set_int64 (value, ephy_embed_persist_get_max_size (persist));
 480                         break;
 481                 case PROP_PERSISTKEY:
 482                         g_value_set_string (value, ephy_embed_persist_get_persist_key (persist));
 483                         break;
 484                 case PROP_SOURCE:
 485                         g_value_set_string (value, ephy_embed_persist_get_source (persist));
 486                         break;
 487                 case PROP_USER_TIME:
 488                         g_value_set_uint (value, ephy_embed_persist_get_user_time (persist));
 489                         break;
 490         }
 491 }
 492
 493 static void
 494 ephy_embed_persist_init (EphyEmbedPersist *persist)
 495 {
 496         persist->priv = EPHY_EMBED_PERSIST_GET_PRIVATE (persist);
 497
 498         LOG ("EphyEmbedPersist initialising %p", persist);
 499
 500         persist->priv->max_size = -1;
 501
 502         ephy_embed_persist_set_user_time (persist, gtk_get_current_event_time ());
 503 }
 504
 505 static void
 506 ephy_embed_persist_finalize (GObject *object)
 507 {
 508         EphyEmbedPersist *persist = EPHY_EMBED_PERSIST (object);
 509         EphyEmbedPersistPrivate *priv = persist->priv;
 510         GtkWindow **wptr;
 511
 512         g_free (priv->dest);
 513         g_free (priv->source);
 514         g_free (priv->fc_title);
 515         g_free (priv->persist_key);
 516
 517         if (priv->fc_parent != NULL)
 518         {
 519                 wptr = &priv->fc_parent;
 520                 g_object_remove_weak_pointer (G_OBJECT (priv->fc_parent),
 521                                               (gpointer *) wptr);
 522         }
 523
 524         LOG ("EphyEmbedPersist finalised %p", object);
 525
 526         G_OBJECT_CLASS (parent_class)->finalize (object);
 527 }
 528
 529 static void
 530 ephy_embed_persist_class_init (EphyEmbedPersistClass *klass)
 531 {
 532         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 533
 534         parent_class = g_type_class_peek_parent (klass);
 535
 536         object_class->finalize = ephy_embed_persist_finalize;
 537         object_class->set_property = ephy_embed_persist_set_property;
 538         object_class->get_property = ephy_embed_persist_get_property;
 539
 540         /* init signals */
 541 /**
 542  * EphyEmbedPersist::completed:
 543  *
 544  * The ::completed signal is emitted when @persist has finished downloading. The
 545  * download must have started with ephy_embed_persist_save().
 546  **/
 547         g_signal_new ("completed",
 548                       G_OBJECT_CLASS_TYPE (object_class),
 549                       G_SIGNAL_RUN_LAST,
 550                       G_STRUCT_OFFSET (EphyEmbedPersistClass, completed),
 551                       NULL, NULL,
 552                       g_cclosure_marshal_VOID__VOID,
 553                       G_TYPE_NONE,
 554                       0);
 555 /**
 556  * EphyEmbedPersist::cancelled:
 557  *
 558  * The ::cancelled signal is emitted when @persist's download has been
 559  * cancelled with ephy_embed_persist_cancel().
 560  **/
 561         g_signal_new ("cancelled",
 562                       G_OBJECT_CLASS_TYPE (object_class),
 563                       G_SIGNAL_RUN_LAST,
 564                       G_STRUCT_OFFSET (EphyEmbedPersistClass, cancelled),
 565                       NULL, NULL,
 566                       g_cclosure_marshal_VOID__VOID,
 567                       G_TYPE_NONE,
 568                       0);
 569
 570         g_object_class_install_property (object_class,
 571                                          PROP_DEST,
 572                                          g_param_spec_string ("dest",
 573                                                               "Destination",
 574                                                               "Destination file path",
 575                                                               NULL,
 576                                                               G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 577
 578         g_object_class_install_property (object_class,
 579                                          PROP_EMBED,
 580                                          g_param_spec_object ("embed",
 581                                                               "Embed",
 582                                                               "The embed containing the document",
 583                                                               G_TYPE_OBJECT,
 584                                                               G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB |
 585                                                               G_PARAM_CONSTRUCT_ONLY));
 586
 587         g_object_class_install_property (object_class,
 588                                          PROP_FILECHOOSER_TITLE,
 589                                          g_param_spec_string  ("filechooser-title",
 590                                                                "Filechooser title",
 591                                                                "Title to use if showing filechooser",
 592                                                                NULL,
 593                                                                G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 594
 595         g_object_class_install_property (object_class,
 596                                          PROP_FILECHOOSER_PARENT,
 597                                          g_param_spec_object ("filechooser-parent",
 598                                                               "Filechooser parent",
 599                                                               "The parent window for the filechooser",
 600                                                               GTK_TYPE_WINDOW,
 601                                                               G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 602
 603         g_object_class_install_property (object_class,
 604                                          PROP_FLAGS,
 605                                          g_param_spec_flags  ("flags",
 606                                                               "Flags",
 607                                                               "Flags",
 608                                                               EPHY_TYPE_EMBED_PERSIST_FLAGS,
 609                                                               0,
 610                                                               G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 611
 612         g_object_class_install_property (object_class,
 613                                          PROP_MAX_SIZE,
 614                                          g_param_spec_int64  ("max-size",
 615                                                               "Maxsize",
 616                                                               "Maximum size of the file",
 617                                                               -1,
 618                                                               G_MAXINT64,
 619                                                               -1,
 620                                                               G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 621
 622         g_object_class_install_property (object_class,
 623                                          PROP_PERSISTKEY,
 624                                          g_param_spec_string  ("persist-key",
 625                                                                "persist key",
 626                                                                "Path persistence gconf key",
 627                                                                NULL,
 628                                                                G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 629
 630         g_object_class_install_property (object_class,
 631                                          PROP_SOURCE,
 632                                          g_param_spec_string  ("source",
 633                                                                "Source",
 634                                                                "Url of the document to save",
 635                                                                NULL,
 636                                                                G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 637
 638         g_object_class_install_property (object_class,
 639                                          PROP_USER_TIME,
 640                                          g_param_spec_uint   ("user-time",
 641                                                               "User Time",
 642                                                               "User Time",
 643                                                               0,
 644                                                               G_MAXUINT,
 645                                                               0,
 646                                                               G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB));
 647
 648         g_type_class_add_private (object_class, sizeof(EphyEmbedPersistPrivate));
 649 }
 650
 651 /**
 652  * ephy_embed_persist_cancel:
 653  * @persist: an #EphyEmbedPersist
 654  *
 655  * Cancels @persist's download. This will not delete the partially downloaded
 656  * file.
 657  **/
 658 void
 659 ephy_embed_persist_cancel (EphyEmbedPersist *persist)
 660 {
 661         EphyEmbedPersistClass *klass = EPHY_EMBED_PERSIST_GET_CLASS (persist);
 662         klass->cancel (persist);
 663 }
 664
 665 /**
 666  * ephy_embed_persist_save:
 667  * @persist: an #EphyEmbedPersist
 668  *
 669  * Begins saving the file specified in @persist.
 670  *
 671  * If @persist's #EphyEmbedPersistFlags include %EPHY_EMBED_PERSIST_ASK_DESTINATION, a
 672  * filechooser dialog will be shown first.
 673  *
 674  * The file will continue to download in the background until either the
 675  * ::completed or the ::cancelled signals are emitted by @persist.
 676  *
 677  * Return value: %TRUE if the download began successfully
 678  **/
 679 gboolean
 680 ephy_embed_persist_save (EphyEmbedPersist *persist)
 681 {
 682         EphyEmbedPersistClass *klass = EPHY_EMBED_PERSIST_GET_CLASS (persist);
 683         return klass->save (persist);
 684 }
 685
 686 /**
 687  * ephy_embed_persist_to_string:
 688  * @persist: an #EphyEmbedPersist
 689  *
 690  * Returns the download specified by @persist as a string instead of downloading
 691  * it to a file.
 692  *
 693  * The download is synchronous. An #EphyEmbed must be specified with
 694  * ephy_embed_persist_set_embed(). The function implicitly assumes that
 695  * @persist's #EphyEmbedPersistFlags include %EPHY_EMBED_PERSIST_COPY_PAGE. If @persist's
 696  * #EphyEmbed has not finished downloading, this function will only return the
 697  * portion of data which has already been downloaded.
 698  *
 699  * The document will be modified: it will only include absolute links and it
 700  * will be encoded as UTF-8.
 701  *
 702  * Return value: The contents of @persist's #EphyEmbed's web page
 703  **/
 704 char *
 705 ephy_embed_persist_to_string (EphyEmbedPersist *persist)
 706 {
 707        EphyEmbedPersistClass *klass = EPHY_EMBED_PERSIST_GET_CLASS (persist);
 708        return klass->to_string (persist);
 709 }