src/ephy-spinner.c

   1 /*
   2  * Copyright © 2000 Eazel, Inc.
   3  * Copyright © 2002-2004 Marco Pesenti Gritti
   4  * Copyright © 2004, 2006 Christian Persch
   5  *
   6  * Nautilus is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Nautilus is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * Author: Andy Hertzfeld <andy@eazel.com>
  21  *
  22  * Ephy port by Marco Pesenti Gritti <marco@it.gnome.org>
  23  *
  24  * $Id: ephy-spinner.c 2114 2006-12-25 12:15:00Z mr $
  25  */
  26
  27 #include <config.h>
  28
  29 #include "ephy-spinner.h"
  30
  31 /* #include "ephy-debug.h" */
  32 #define LOG(msg, args...)
  33 #define START_PROFILER(name)
  34 #define STOP_PROFILER(name)
  35
  36 #include <gdk-pixbuf/gdk-pixbuf.h>
  37 #include <gtk/gtk.h>
  38
  39 /* Spinner cache implementation */
  40
  41 #define EPHY_TYPE_SPINNER_CACHE                 (ephy_spinner_cache_get_type())
  42 #define EPHY_SPINNER_CACHE(object)              (G_TYPE_CHECK_INSTANCE_CAST((object), EPHY_TYPE_SPINNER_CACHE, EphySpinnerCache))
  43 #define EPHY_SPINNER_CACHE_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST((klass), EPHY_TYPE_SPINNER_CACHE, EphySpinnerCacheClass))
  44 #define EPHY_IS_SPINNER_CACHE(object)           (G_TYPE_CHECK_INSTANCE_TYPE((object), EPHY_TYPE_SPINNER_CACHE))
  45 #define EPHY_IS_SPINNER_CACHE_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE((klass), EPHY_TYPE_SPINNER_CACHE))
  46 #define EPHY_SPINNER_CACHE_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS((obj), EPHY_TYPE_SPINNER_CACHE, EphySpinnerCacheClass))
  47
  48 typedef struct _EphySpinnerCache        EphySpinnerCache;
  49 typedef struct _EphySpinnerCacheClass   EphySpinnerCacheClass;
  50 typedef struct _EphySpinnerCachePrivate EphySpinnerCachePrivate;
  51
  52 struct _EphySpinnerCacheClass
  53 {
  54         GObjectClass parent_class;
  55 };
  56
  57 struct _EphySpinnerCache
  58 {
  59         GObject parent_object;
  60
  61         /*< private >*/
  62         EphySpinnerCachePrivate *priv;
  63 };
  64
  65 #define EPHY_SPINNER_CACHE_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_SPINNER_CACHE, EphySpinnerCachePrivate))
  66
  67 struct _EphySpinnerCachePrivate
  68 {
  69         /* Hash table of GdkScreen -> EphySpinnerCacheData */
  70         GHashTable *hash;
  71 };
  72
  73 typedef struct
  74 {
  75         guint ref_count;
  76         GtkIconSize size;
  77         int width;
  78         int height;
  79         GdkPixbuf **animation_pixbufs;
  80         guint n_animation_pixbufs;
  81 } EphySpinnerImages;
  82
  83 #define LAST_ICON_SIZE                  GTK_ICON_SIZE_DIALOG + 1
  84 #define SPINNER_ICON_NAME               "process-working"
  85 #define SPINNER_FALLBACK_ICON_NAME      "gnome-spinner"
  86 #define EPHY_SPINNER_IMAGES_INVALID     ((EphySpinnerImages *) 0x1)
  87
  88 typedef struct
  89 {
  90         GdkScreen *screen;
  91         GtkIconTheme *icon_theme;
  92         EphySpinnerImages *images[LAST_ICON_SIZE];
  93 } EphySpinnerCacheData;
  94
  95 static void ephy_spinner_cache_class_init (EphySpinnerCacheClass *klass);
  96 static void ephy_spinner_cache_init       (EphySpinnerCache *cache);
  97
  98 static GObjectClass *ephy_spinner_cache_parent_class;
  99
 100 static GType
 101 ephy_spinner_cache_get_type (void)
 102 {
 103         static GType type = 0;
 104
 105         if (G_UNLIKELY (type == 0))
 106         {
 107                 const GTypeInfo our_info =
 108                 {
 109                         sizeof (EphySpinnerCacheClass),
 110                         NULL,
 111                         NULL,
 112                         (GClassInitFunc) ephy_spinner_cache_class_init,
 113                         NULL,
 114                         NULL,
 115                         sizeof (EphySpinnerCache),
 116                         0,
 117                         (GInstanceInitFunc) ephy_spinner_cache_init
 118                 };
 119
 120                 type = g_type_register_static (G_TYPE_OBJECT,
 121                                                "EphySpinnerCache",
 122                                                &our_info, 0);
 123         }
 124
 125         return type;
 126 }
 127
 128 static EphySpinnerImages *
 129 ephy_spinner_images_ref (EphySpinnerImages *images)
 130 {
 131         g_return_val_if_fail (images != NULL, NULL);
 132
 133         images->ref_count++;
 134
 135         return images;
 136 }
 137
 138 static void
 139 ephy_spinner_images_unref (EphySpinnerImages *images)
 140 {
 141         g_return_if_fail (images != NULL);
 142
 143         images->ref_count--;
 144         if (images->ref_count == 0)
 145         {
 146                 guint i;
 147
 148                 LOG ("Freeing spinner images %p for size %d", images, images->size);
 149
 150                 for (i = 0; i < images->n_animation_pixbufs; ++i)
 151                 {
 152                         g_object_unref (images->animation_pixbufs[i]);
 153                 }
 154                 g_free (images->animation_pixbufs);
 155
 156                 g_free (images);
 157         }
 158 }
 159
 160 static void
 161 ephy_spinner_cache_data_unload (EphySpinnerCacheData *data)
 162 {
 163         GtkIconSize size;
 164         EphySpinnerImages *images;
 165
 166         g_return_if_fail (data != NULL);
 167
 168         LOG ("EphySpinnerDataCache unload for screen %p", data->screen);
 169
 170         for (size = GTK_ICON_SIZE_INVALID; size < LAST_ICON_SIZE; ++size)
 171         {
 172                 images = data->images[size];
 173                 data->images[size] = NULL;
 174
 175                 if (images != NULL && images != EPHY_SPINNER_IMAGES_INVALID)
 176                 {
 177                         ephy_spinner_images_unref (images);
 178                 }
 179         }
 180 }
 181
 182 static GdkPixbuf *
 183 extract_frame (GdkPixbuf *grid_pixbuf,
 184                int x,
 185                int y,
 186                int size)
 187 {
 188         GdkPixbuf *pixbuf;
 189
 190         if (x + size > gdk_pixbuf_get_width (grid_pixbuf) ||
 191             y + size > gdk_pixbuf_get_height (grid_pixbuf))
 192         {
 193                 return NULL;
 194         }
 195
 196         pixbuf = gdk_pixbuf_new_subpixbuf (grid_pixbuf,
 197                                            x, y,
 198                                            size, size);
 199         g_return_val_if_fail (pixbuf != NULL, NULL);
 200
 201         return pixbuf;
 202 }
 203
 204 static GdkPixbuf *
 205 scale_to_size (GdkPixbuf *pixbuf,
 206                int dw,
 207                int dh)
 208 {
 209         GdkPixbuf *result;
 210         int pw, ph;
 211
 212         g_return_val_if_fail (pixbuf != NULL, NULL);
 213
 214         pw = gdk_pixbuf_get_width (pixbuf);
 215         ph = gdk_pixbuf_get_height (pixbuf);
 216
 217         if (pw != dw || ph != dh)
 218         {
 219                 result = gdk_pixbuf_scale_simple (pixbuf, dw, dh,
 220                                                   GDK_INTERP_BILINEAR);
 221                 g_object_unref (pixbuf);
 222                 return result;
 223         }
 224
 225         return pixbuf;
 226 }
 227
 228 static EphySpinnerImages *
 229 ephy_spinner_images_load (GdkScreen *screen,
 230                           GtkIconTheme *icon_theme,
 231                           GtkIconSize icon_size)
 232 {
 233         EphySpinnerImages *images;
 234         GdkPixbuf *icon_pixbuf, *pixbuf;
 235         GtkIconInfo *icon_info = NULL;
 236         int grid_width, grid_height, x, y, requested_size, size, isw, ish, n;
 237         const char *icon;
 238         GSList *list = NULL, *l;
 239
 240         LOG ("EphySpinnerCacheData loading for screen %p at size %d", screen, icon_size);
 241
 242         START_PROFILER ("loading spinner animation")
 243
 244         if (!gtk_icon_size_lookup_for_settings (gtk_settings_get_for_screen (screen),
 245                                                 icon_size, &isw, &ish)) goto loser;
 246
 247         requested_size = MAX (ish, isw);
 248
 249         /* Load the animation. The 'rest icon' is the 0th frame */
 250         icon_info = gtk_icon_theme_lookup_icon (icon_theme,
 251                                                 SPINNER_ICON_NAME,
 252                                                 requested_size, 0);
 253         if (icon_info == NULL)
 254         {
 255                 g_warning ("Throbber animation not found");
 256
 257                 /* If the icon naming spec compliant name wasn't found, try the old name */
 258                 icon_info = gtk_icon_theme_lookup_icon (icon_theme,
 259                                                         SPINNER_FALLBACK_ICON_NAME,
 260                                                         requested_size, 0);
 261                 if (icon_info == NULL)
 262                 {
 263                         g_warning ("Throbber fallback animation not found either");
 264                         goto loser;
 265                 }
 266         }
 267         g_assert (icon_info != NULL);
 268
 269         size = gtk_icon_info_get_base_size (icon_info);
 270         icon = gtk_icon_info_get_filename (icon_info);
 271         if (icon == NULL) goto loser;
 272
 273         icon_pixbuf = gdk_pixbuf_new_from_file (icon, NULL);
 274         gtk_icon_info_free (icon_info);
 275         icon_info = NULL;
 276
 277         if (icon_pixbuf == NULL)
 278         {
 279                 g_warning ("Could not load the spinner file");
 280                 goto loser;
 281         }
 282
 283         grid_width = gdk_pixbuf_get_width (icon_pixbuf);
 284         grid_height = gdk_pixbuf_get_height (icon_pixbuf);
 285
 286         n = 0;
 287         for (y = 0; y < grid_height; y += size)
 288         {
 289                 for (x = 0; x < grid_width ; x += size)
 290                 {
 291                         pixbuf = extract_frame (icon_pixbuf, x, y, size);
 292
 293                         if (pixbuf)
 294                         {
 295                                 list = g_slist_prepend (list, pixbuf);
 296                                 ++n;
 297                         }
 298                         else
 299                         {
 300                                 g_warning ("Cannot extract frame (%d, %d) from the grid\n", x, y);
 301                         }
 302                 }
 303         }
 304
 305         g_object_unref (icon_pixbuf);
 306
 307         if (list == NULL) goto loser;
 308         g_assert (n > 0);
 309
 310         if (size > requested_size)
 311         {
 312                 for (l = list; l != NULL; l = l->next)
 313                 {
 314                         l->data = scale_to_size (l->data, isw, ish);
 315                 }
 316         }
 317
 318         /* Now we've successfully got all the data */
 319         images = g_new (EphySpinnerImages, 1);
 320         images->ref_count = 1;
 321
 322         images->size = icon_size;
 323         images->width = images->height = requested_size;
 324
 325         images->n_animation_pixbufs = n;
 326         images->animation_pixbufs = g_new (GdkPixbuf *, n);
 327
 328         for (l = list; l != NULL; l = l->next)
 329         {
 330                 g_assert (l->data != NULL);
 331                 images->animation_pixbufs[--n] = l->data;
 332         }
 333         g_assert (n == 0);
 334
 335         g_slist_free (list);
 336
 337         STOP_PROFILER ("loading spinner animation")
 338
 339         return images;
 340
 341 loser:
 342         if (icon_info)
 343         {
 344                 gtk_icon_info_free (icon_info);
 345         }
 346         g_slist_foreach (list, (GFunc) g_object_unref, NULL);
 347
 348         STOP_PROFILER ("loading spinner animation")
 349
 350         return NULL;
 351 }
 352
 353 static EphySpinnerCacheData *
 354 ephy_spinner_cache_data_new (GdkScreen *screen)
 355 {
 356         EphySpinnerCacheData *data;
 357
 358         data = g_new0 (EphySpinnerCacheData, 1);
 359
 360         data->screen = screen;
 361         data->icon_theme = gtk_icon_theme_get_for_screen (screen);
 362         g_signal_connect_swapped (data->icon_theme, "changed",
 363                                   G_CALLBACK (ephy_spinner_cache_data_unload),
 364                                   data);
 365
 366         return data;
 367 }
 368
 369 static void
 370 ephy_spinner_cache_data_free (EphySpinnerCacheData *data)
 371 {
 372         g_return_if_fail (data != NULL);
 373         g_return_if_fail (data->icon_theme != NULL);
 374
 375         g_signal_handlers_disconnect_by_func
 376                 (data->icon_theme,
 377                  G_CALLBACK (ephy_spinner_cache_data_unload), data);
 378
 379         ephy_spinner_cache_data_unload (data);
 380
 381         g_free (data);
 382 }
 383
 384 static EphySpinnerImages *
 385 ephy_spinner_cache_get_images (EphySpinnerCache *cache,
 386                                GdkScreen *screen,
 387                                GtkIconSize icon_size)
 388 {
 389         EphySpinnerCachePrivate *priv = cache->priv;
 390         EphySpinnerCacheData *data;
 391         EphySpinnerImages *images;
 392
 393         LOG ("Getting animation images for screen %p at size %d", screen, icon_size);
 394
 395         g_return_val_if_fail (icon_size < LAST_ICON_SIZE, NULL);
 396
 397         /* Backward compat: "invalid" meant "native" size which doesn't exist anymore */
 398         if (icon_size == GTK_ICON_SIZE_INVALID)
 399         {
 400                 icon_size = GTK_ICON_SIZE_DIALOG;
 401         }
 402
 403         data = g_hash_table_lookup (priv->hash, screen);
 404         if (data == NULL)
 405         {
 406                 data = ephy_spinner_cache_data_new (screen);
 407                 /* FIXME: think about what happens when the screen's display is closed later on */
 408                 g_hash_table_insert (priv->hash, screen, data);
 409         }
 410
 411         images = data->images[icon_size];
 412         if (images == EPHY_SPINNER_IMAGES_INVALID)
 413         {
 414                 /* Load failed, but don't try endlessly again! */
 415                 return NULL;
 416         }
 417
 418         if (images != NULL)
 419         {
 420                 /* Return cached data */
 421                 return ephy_spinner_images_ref (images);
 422         }
 423
 424         images = ephy_spinner_images_load (screen, data->icon_theme, icon_size);
 425
 426         if (images == NULL)
 427         {
 428                 /* Mark as failed-to-load */
 429                 data->images[icon_size] = EPHY_SPINNER_IMAGES_INVALID;
 430
 431                 return NULL;
 432         }
 433
 434         data->images[icon_size] = images;
 435
 436         return ephy_spinner_images_ref (images);
 437 }
 438
 439 static void
 440 ephy_spinner_cache_init (EphySpinnerCache *cache)
 441 {
 442         EphySpinnerCachePrivate *priv;
 443
 444         priv = cache->priv = EPHY_SPINNER_CACHE_GET_PRIVATE (cache);
 445
 446         LOG ("EphySpinnerCache initialising");
 447
 448         priv->hash = g_hash_table_new_full (g_direct_hash, g_direct_equal,
 449                                             NULL,
 450                                             (GDestroyNotify) ephy_spinner_cache_data_free);
 451 }
 452
 453 static void
 454 ephy_spinner_cache_finalize (GObject *object)
 455 {
 456         EphySpinnerCache *cache = EPHY_SPINNER_CACHE (object);
 457         EphySpinnerCachePrivate *priv = cache->priv;
 458
 459         g_hash_table_destroy (priv->hash);
 460
 461         LOG ("EphySpinnerCache finalised");
 462
 463         G_OBJECT_CLASS (ephy_spinner_cache_parent_class)->finalize (object);
 464 }
 465
 466 static void
 467 ephy_spinner_cache_class_init (EphySpinnerCacheClass *klass)
 468 {
 469         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 470
 471         ephy_spinner_cache_parent_class = g_type_class_peek_parent (klass);
 472
 473         object_class->finalize = ephy_spinner_cache_finalize;
 474
 475         g_type_class_add_private (object_class, sizeof (EphySpinnerCachePrivate));
 476 }
 477
 478 static EphySpinnerCache *spinner_cache = NULL;
 479
 480 static EphySpinnerCache *
 481 ephy_spinner_cache_ref (void)
 482 {
 483         if (spinner_cache == NULL)
 484         {
 485                 EphySpinnerCache **cache_ptr;
 486
 487                 spinner_cache = g_object_new (EPHY_TYPE_SPINNER_CACHE, NULL);
 488                 cache_ptr = &spinner_cache;
 489                 g_object_add_weak_pointer (G_OBJECT (spinner_cache),
 490                                            (gpointer) cache_ptr);
 491
 492                 return spinner_cache;
 493         }
 494
 495         return g_object_ref (spinner_cache);
 496 }
 497
 498 /* Spinner implementation */
 499
 500 #define SPINNER_TIMEOUT 125 /* ms */
 501
 502 #define EPHY_SPINNER_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_SPINNER, EphySpinnerDetails))
 503
 504 struct _EphySpinnerDetails
 505 {
 506         GtkIconTheme *icon_theme;
 507         EphySpinnerCache *cache;
 508         GtkIconSize size;
 509         EphySpinnerImages *images;
 510         guint current_image;
 511         guint timeout;
 512         guint timer_task;
 513         guint spinning : 1;
 514         guint need_load : 1;
 515 };
 516
 517 static void ephy_spinner_class_init (EphySpinnerClass *class);
 518 static void ephy_spinner_init       (EphySpinner *spinner);
 519
 520 static GObjectClass *parent_class;
 521
 522 GType
 523 ephy_spinner_get_type (void)
 524 {
 525         static GType type = 0;
 526
 527         if (G_UNLIKELY (type == 0))
 528         {
 529                 const GTypeInfo our_info =
 530                 {
 531                         sizeof (EphySpinnerClass),
 532                         NULL, /* base_init */
 533                         NULL, /* base_finalize */
 534                         (GClassInitFunc) ephy_spinner_class_init,
 535                         NULL,
 536                         NULL, /* class_data */
 537                         sizeof (EphySpinner),
 538                         0, /* n_preallocs */
 539                         (GInstanceInitFunc) ephy_spinner_init
 540                 };
 541
 542                 type = g_type_register_static (GTK_TYPE_WIDGET,
 543                                                "EphySpinner",
 544                                                &our_info, 0);
 545         }
 546
 547         return type;
 548 }
 549
 550 static gboolean
 551 ephy_spinner_load_images (EphySpinner *spinner)
 552 {
 553         EphySpinnerDetails *details = spinner->details;
 554
 555         if (details->need_load)
 556         {
 557                 START_PROFILER ("ephy_spinner_load_images")
 558
 559                 details->images =
 560                         ephy_spinner_cache_get_images
 561                                 (details->cache,
 562                                  gtk_widget_get_screen (GTK_WIDGET (spinner)),
 563                                  details->size);
 564
 565                 STOP_PROFILER ("ephy_spinner_load_images")
 566
 567                 details->current_image = 0; /* 'rest' icon */
 568                 details->need_load = FALSE;
 569         }
 570
 571         return details->images != NULL;
 572 }
 573
 574 static void
 575 ephy_spinner_unload_images (EphySpinner *spinner)
 576 {
 577         EphySpinnerDetails *details = spinner->details;
 578
 579         if (details->images != NULL)
 580         {
 581                 ephy_spinner_images_unref (details->images);
 582                 details->images = NULL;
 583         }
 584
 585         details->current_image = 0;
 586         details->need_load = TRUE;
 587 }
 588
 589 static void
 590 icon_theme_changed_cb (GtkIconTheme *icon_theme,
 591                        EphySpinner *spinner)
 592 {
 593         ephy_spinner_unload_images (spinner);
 594         gtk_widget_queue_resize (GTK_WIDGET (spinner));
 595 }
 596
 597 static void
 598 ephy_spinner_init (EphySpinner *spinner)
 599 {
 600         EphySpinnerDetails *details;
 601
 602         details = spinner->details = EPHY_SPINNER_GET_PRIVATE (spinner);
 603
 604         gtk_widget_set_has_window (GTK_WIDGET (spinner), FALSE);
 605
 606         details->cache = ephy_spinner_cache_ref ();
 607         details->size = GTK_ICON_SIZE_DIALOG;
 608         details->spinning = FALSE;
 609         details->timeout = SPINNER_TIMEOUT;
 610         details->need_load = TRUE;
 611 }
 612
 613 static int
 614 ephy_spinner_expose (GtkWidget *widget,
 615                      GdkEventExpose *event)
 616 {
 617         EphySpinner *spinner = EPHY_SPINNER (widget);
 618         EphySpinnerDetails *details = spinner->details;
 619         EphySpinnerImages *images;
 620         GdkPixbuf *pixbuf;
 621         GdkGC *gc;
 622         int x_offset, y_offset, width, height;
 623         GdkRectangle pix_area, dest;
 624         GtkAllocation allocation;
 625
 626         if (!gtk_widget_is_drawable (GTK_WIDGET (spinner)))
 627         {
 628                 return FALSE;
 629         }
 630
 631         if (details->need_load &&
 632             !ephy_spinner_load_images (spinner))
 633         {
 634                 return FALSE;
 635         }
 636
 637         images = details->images;
 638         if (images == NULL)
 639         {
 640                 return FALSE;
 641         }
 642
 643         /* Otherwise |images| will be NULL anyway */
 644         g_assert (images->n_animation_pixbufs > 0);
 645
 646         g_assert (details->current_image < images->n_animation_pixbufs);
 647
 648         pixbuf = images->animation_pixbufs[details->current_image];
 649
 650         g_assert (pixbuf != NULL);
 651
 652         width = gdk_pixbuf_get_width (pixbuf);
 653         height = gdk_pixbuf_get_height (pixbuf);
 654
 655         /* Compute the offsets for the image centered on our allocation */
 656         gtk_widget_get_allocation (widget, &allocation);
 657         x_offset = (allocation.width - width) / 2;
 658         y_offset = (allocation.height - height) / 2;
 659
 660         pix_area.x = x_offset + allocation.x;
 661         pix_area.y = y_offset + allocation.y;
 662         pix_area.width = width;
 663         pix_area.height = height;
 664
 665         if (!gdk_rectangle_intersect (&event->area, &pix_area, &dest))
 666         {
 667                 return FALSE;
 668         }
 669
 670         gc = gdk_gc_new (gtk_widget_get_window (widget));
 671         gdk_draw_pixbuf (gtk_widget_get_window (widget), gc, pixbuf,
 672                          dest.x - x_offset - allocation.x,
 673                          dest.y - y_offset - allocation.y,
 674                          dest.x, dest.y,
 675                          dest.width, dest.height,
 676                          GDK_RGB_DITHER_MAX, 0, 0);
 677         g_object_unref (gc);
 678
 679         return FALSE;
 680 }
 681
 682 static gboolean
 683 bump_spinner_frame_cb (EphySpinner *spinner)
 684 {
 685         EphySpinnerDetails *details = spinner->details;
 686
 687         /* This can happen when we've unloaded the images on a theme
 688          * change, but haven't been in the queued size request yet.
 689          * Just skip this update.
 690          */
 691         if (details->images == NULL) return TRUE;
 692
 693         details->current_image++;
 694         if (details->current_image >= details->images->n_animation_pixbufs)
 695         {
 696                 /* the 0th frame is the 'rest' icon */
 697                 details->current_image = MIN (1, details->images->n_animation_pixbufs);
 698         }
 699
 700         gtk_widget_queue_draw (GTK_WIDGET (spinner));
 701
 702         /* run again */
 703         return TRUE;
 704 }
 705
 706 /**
 707  * ephy_spinner_start:
 708  * @spinner: a #EphySpinner
 709  *
 710  * Start the spinner animation.
 711  **/
 712 void
 713 ephy_spinner_start (EphySpinner *spinner)
 714 {
 715         EphySpinnerDetails *details = spinner->details;
 716
 717         details->spinning = TRUE;
 718
 719         if (GTK_WIDGET_MAPPED (GTK_WIDGET (spinner)) &&
 720             details->timer_task == 0 &&
 721             ephy_spinner_load_images (spinner))
 722         {
 723                 /* the 0th frame is the 'rest' icon */
 724                 details->current_image = MIN (1, details->images->n_animation_pixbufs);
 725
 726                 details->timer_task =
 727                         g_timeout_add_full (G_PRIORITY_LOW,
 728                                             details->timeout,
 729                                             (GSourceFunc) bump_spinner_frame_cb,
 730                                             spinner,
 731                                             NULL);
 732         }
 733 }
 734
 735 static void
 736 ephy_spinner_remove_update_callback (EphySpinner *spinner)
 737 {
 738         EphySpinnerDetails *details = spinner->details;
 739
 740         if (details->timer_task != 0)
 741         {
 742                 g_source_remove (details->timer_task);
 743                 details->timer_task = 0;
 744         }
 745 }
 746
 747 /**
 748  * ephy_spinner_stop:
 749  * @spinner: a #EphySpinner
 750  *
 751  * Stop the spinner animation.
 752  **/
 753 void
 754 ephy_spinner_stop (EphySpinner *spinner)
 755 {
 756         EphySpinnerDetails *details = spinner->details;
 757
 758         details->spinning = FALSE;
 759         details->current_image = 0;
 760
 761         if (details->timer_task != 0)
 762         {
 763                 ephy_spinner_remove_update_callback (spinner);
 764
 765                 if (GTK_WIDGET_MAPPED (GTK_WIDGET (spinner)))
 766                 {
 767                         gtk_widget_queue_draw (GTK_WIDGET (spinner));
 768                 }
 769         }
 770 }
 771
 772 /*
 773  * ephy_spinner_set_size:
 774  * @spinner: a #EphySpinner
 775  * @size: the size of type %GtkIconSize
 776  *
 777  * Set the size of the spinner.
 778  **/
 779 void
 780 ephy_spinner_set_size (EphySpinner *spinner,
 781                        GtkIconSize size)
 782 {
 783         if (size == GTK_ICON_SIZE_INVALID)
 784         {
 785                 size = GTK_ICON_SIZE_DIALOG;
 786         }
 787
 788         if (size != spinner->details->size)
 789         {
 790                 ephy_spinner_unload_images (spinner);
 791
 792                 spinner->details->size = size;
 793
 794                 gtk_widget_queue_resize (GTK_WIDGET (spinner));
 795         }
 796 }
 797
 798 #if 0
 799 /*
 800  * ephy_spinner_set_timeout:
 801  * @spinner: a #EphySpinner
 802  * @timeout: time delay between updates to the spinner.
 803  *
 804  * Sets the timeout delay for spinner updates.
 805  **/
 806 void
 807 ephy_spinner_set_timeout (EphySpinner *spinner,
 808                           guint timeout)
 809 {
 810         EphySpinnerDetails *details = spinner->details;
 811
 812         if (timeout != details->timeout)
 813         {
 814                 ephy_spinner_stop (spinner);
 815
 816                 details->timeout = timeout;
 817
 818                 if (details->spinning)
 819                 {
 820                         ephy_spinner_start (spinner);
 821                 }
 822         }
 823 }
 824 #endif
 825
 826 static void
 827 ephy_spinner_size_request (GtkWidget *widget,
 828                            GtkRequisition *requisition)
 829 {
 830         EphySpinner *spinner = EPHY_SPINNER (widget);
 831         EphySpinnerDetails *details = spinner->details;
 832
 833         if ((details->need_load &&
 834              !ephy_spinner_load_images (spinner)) ||
 835             details->images == NULL)
 836         {
 837                 requisition->width = requisition->height = 0;
 838                 gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (widget),
 839                                                    details->size,
 840                                                    &requisition->width,
 841                                                    &requisition->height);
 842                 return;
 843         }
 844
 845         requisition->width = details->images->width;
 846         requisition->height = details->images->height;
 847
 848         /* FIXME fix this hack */
 849         /* allocate some extra margin so we don't butt up against toolbar edges */
 850         if (details->size != GTK_ICON_SIZE_MENU)
 851         {
 852                 requisition->width += 2;
 853                 requisition->height += 2;
 854         }
 855 }
 856
 857 static void
 858 ephy_spinner_map (GtkWidget *widget)
 859 {
 860         EphySpinner *spinner = EPHY_SPINNER (widget);
 861         EphySpinnerDetails *details = spinner->details;
 862
 863         GTK_WIDGET_CLASS (parent_class)->map (widget);
 864
 865         if (details->spinning)
 866         {
 867                 ephy_spinner_start (spinner);
 868         }
 869 }
 870
 871 static void
 872 ephy_spinner_unmap (GtkWidget *widget)
 873 {
 874         EphySpinner *spinner = EPHY_SPINNER (widget);
 875
 876         ephy_spinner_remove_update_callback (spinner);
 877
 878         GTK_WIDGET_CLASS (parent_class)->unmap (widget);
 879 }
 880
 881 static void
 882 ephy_spinner_dispose (GObject *object)
 883 {
 884         EphySpinner *spinner = EPHY_SPINNER (object);
 885
 886         g_signal_handlers_disconnect_by_func
 887                         (spinner->details->icon_theme,
 888                  G_CALLBACK (icon_theme_changed_cb), spinner);
 889
 890         G_OBJECT_CLASS (parent_class)->dispose (object);
 891 }
 892
 893 static void
 894 ephy_spinner_finalize (GObject *object)
 895 {
 896         EphySpinner *spinner = EPHY_SPINNER (object);
 897
 898         ephy_spinner_remove_update_callback (spinner);
 899         ephy_spinner_unload_images (spinner);
 900
 901         g_object_unref (spinner->details->cache);
 902
 903         G_OBJECT_CLASS (parent_class)->finalize (object);
 904 }
 905
 906 static void
 907 ephy_spinner_screen_changed (GtkWidget *widget,
 908                              GdkScreen *old_screen)
 909 {
 910         EphySpinner *spinner = EPHY_SPINNER (widget);
 911         EphySpinnerDetails *details = spinner->details;
 912         GdkScreen *screen;
 913
 914         if (GTK_WIDGET_CLASS (parent_class)->screen_changed)
 915         {
 916                 GTK_WIDGET_CLASS (parent_class)->screen_changed (widget, old_screen);
 917         }
 918
 919         screen = gtk_widget_get_screen (widget);
 920
 921         /* FIXME: this seems to be happening when then spinner is destroyed!? */
 922         if (old_screen == screen) return;
 923
 924         /* We'll get mapped again on the new screen, but not unmapped from
 925          * the old screen, so remove timeout here.
 926          */
 927         ephy_spinner_remove_update_callback (spinner);
 928
 929         ephy_spinner_unload_images (spinner);
 930
 931         if (old_screen != NULL)
 932         {
 933                 g_signal_handlers_disconnect_by_func
 934                         (gtk_icon_theme_get_for_screen (old_screen),
 935                          G_CALLBACK (icon_theme_changed_cb), spinner);
 936         }
 937
 938         details->icon_theme = gtk_icon_theme_get_for_screen (screen);
 939         g_signal_connect (details->icon_theme, "changed",
 940                           G_CALLBACK (icon_theme_changed_cb), spinner);
 941 }
 942
 943 static void
 944 ephy_spinner_class_init (EphySpinnerClass *class)
 945 {
 946         GObjectClass *object_class =  G_OBJECT_CLASS (class);
 947         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 948
 949         parent_class = g_type_class_peek_parent (class);
 950
 951         object_class->dispose = ephy_spinner_dispose;
 952         object_class->finalize = ephy_spinner_finalize;
 953
 954         widget_class->expose_event = ephy_spinner_expose;
 955         widget_class->size_request = ephy_spinner_size_request;
 956         widget_class->map = ephy_spinner_map;
 957         widget_class->unmap = ephy_spinner_unmap;
 958         widget_class->screen_changed = ephy_spinner_screen_changed;
 959
 960         g_type_class_add_private (object_class, sizeof (EphySpinnerDetails));
 961 }
 962
 963 /*
 964  * ephy_spinner_new:
 965  *
 966  * Create a new #EphySpinner. The spinner is a widget
 967  * that gives the user feedback about network status with
 968  * an animated image.
 969  *
 970  * Return Value: the spinner #GtkWidget
 971  **/
 972 GtkWidget *
 973 ephy_spinner_new (void)
 974 {
 975         return GTK_WIDGET (g_object_new (EPHY_TYPE_SPINNER, NULL));
 976 }