backend/ev-page-cache.c

   1 #include "ev-page-cache.h"
   2 #include "ev-job-queue.h"
   3
   4 typedef struct _EvPageCacheInfo
   5 {
   6         gint width;
   7         gint height;
   8 }
   9 EvPageCacheInfo;
  10
  11
  12 struct _EvPageCache
  13 {
  14         GObject parent;
  15
  16         gint current_page;
  17         int n_pages;
  18         char *title;
  19
  20         gboolean uniform;
  21         gint uniform_width;
  22         gint uniform_height;
  23
  24         EvPageCacheInfo *size_cache;
  25 };
  26
  27 struct _EvPageCacheClass
  28 {
  29         GObjectClass parent_class;
  30
  31         void (* page_changed) (EvPageCache *page_cache, gint page);
  32 };
  33
  34 enum
  35 {
  36         PAGE_CHANGED,
  37         N_SIGNALS,
  38 };
  39
  40 static guint signals[N_SIGNALS] = {0, };
  41
  42 static void ev_page_cache_init       (EvPageCache      *page_cache);
  43 static void ev_page_cache_class_init (EvPageCacheClass *page_cache);
  44 static void ev_page_cache_finalize   (GObject *object);
  45
  46 G_DEFINE_TYPE (EvPageCache, ev_page_cache, G_TYPE_OBJECT)
  47
  48 static void
  49 ev_page_cache_init (EvPageCache *page_cache)
  50 {
  51         page_cache->current_page = 1;
  52 }
  53
  54 static void
  55 ev_page_cache_class_init (EvPageCacheClass *class)
  56 {
  57         GObjectClass *object_class;
  58
  59         object_class = G_OBJECT_CLASS (class);
  60
  61         object_class->finalize = ev_page_cache_finalize;
  62
  63         signals [PAGE_CHANGED] =
  64                 g_signal_new ("page-changed",
  65                               EV_TYPE_PAGE_CACHE,
  66                               G_SIGNAL_RUN_LAST,
  67                               G_STRUCT_OFFSET (EvPageCacheClass, page_changed),
  68                               NULL, NULL,
  69                               g_cclosure_marshal_VOID__INT,
  70                               G_TYPE_NONE, 1,
  71                               G_TYPE_INT);
  72
  73 }
  74
  75 static void
  76 ev_page_cache_finalize (GObject *object)
  77 {
  78         EvPageCache *page_cache;
  79
  80         page_cache = EV_PAGE_CACHE (object);
  81
  82         g_free (page_cache->title);
  83         g_free (page_cache->size_cache);
  84 }
  85
  86 EvPageCache *
  87 _ev_page_cache_new (EvDocument *document)
  88 {
  89         EvPageCache *page_cache;
  90         EvPageCacheInfo *info;
  91         gint i;
  92
  93         page_cache = (EvPageCache *) g_object_new (EV_TYPE_PAGE_CACHE, NULL);
  94
  95         g_mutex_lock (EV_DOC_MUTEX);
  96
  97         /* We read page information out of the document */
  98
  99         /* Assume all pages are the same size until proven otherwise */
 100         page_cache->uniform = TRUE;
 101         page_cache->n_pages = ev_document_get_n_pages (document);
 102         page_cache->title = ev_document_get_title (document);
 103
 104         ev_document_set_scale (document, 1.0);
 105         for (i = 1; i <= page_cache->n_pages; i++) {
 106                 gint page_width = 0;
 107                 gint page_height = 0;
 108
 109                 ev_document_get_page_size (document, i, &page_width, &page_height);
 110
 111                 if (i == 1) {
 112                         page_cache->uniform_width = page_width;
 113                         page_cache->uniform_height = page_height;
 114                 } else if (page_cache->uniform &&
 115                            (page_cache->uniform_width != page_width ||
 116                             page_cache->uniform_height != page_height)) {
 117                         /* It's a different page size.  Backfill the array. */
 118                         int j;
 119
 120                         page_cache->size_cache = g_new0 (EvPageCacheInfo, page_cache->n_pages);
 121
 122                         for (j = 1; j < i; j++) {
 123                                 info = &(page_cache->size_cache [j - 1]);
 124                                 info->width = page_width;
 125                                 info->height = page_height;
 126                         }
 127                         page_cache->uniform = FALSE;
 128
 129                 }
 130
 131                 if (! page_cache->uniform) {
 132                         info = &(page_cache->size_cache [i - 1]);
 133
 134                         info->width = page_width;
 135                         info->height = page_height;
 136                 }
 137         }
 138
 139         /* make some sanity check assertions */
 140         g_assert (page_cache->n_pages > 0);
 141         if (! page_cache->uniform)
 142                 g_assert (page_cache->size_cache != NULL);
 143         if (page_cache->uniform)
 144                 g_assert (page_cache->uniform_width > 0 && page_cache->uniform_height > 0);
 145
 146         g_mutex_unlock (EV_DOC_MUTEX);
 147
 148         return page_cache;
 149 }
 150
 151 gint
 152 ev_page_cache_get_n_pages (EvPageCache *page_cache)
 153 {
 154         g_return_val_if_fail (EV_IS_PAGE_CACHE (page_cache), 0);
 155
 156         return page_cache->n_pages;
 157 }
 158
 159 gint
 160 ev_page_cache_get_current_page (EvPageCache *page_cache)
 161 {
 162         g_return_val_if_fail (EV_IS_PAGE_CACHE (page_cache), 0);
 163
 164         return page_cache->current_page;
 165 }
 166
 167 void
 168 ev_page_cache_set_current_page (EvPageCache *page_cache,
 169                                 int          page)
 170 {
 171         g_return_if_fail (EV_IS_PAGE_CACHE (page_cache));
 172         g_return_if_fail (page > 0 || page <= page_cache->n_pages);
 173
 174         if (page == page_cache->current_page)
 175                 return;
 176
 177         page_cache->current_page = page;
 178         g_signal_emit (page_cache, signals[PAGE_CHANGED], 0, page);
 179 }
 180
 181 void
 182 ev_page_cache_set_link (EvPageCache *page_cache,
 183                         EvLink      *link)
 184 {
 185         g_return_if_fail (EV_IS_PAGE_CACHE (page_cache));
 186         g_return_if_fail (EV_IS_LINK (link));
 187
 188         ev_page_cache_set_current_page (page_cache, ev_link_get_page (link));
 189 }
 190
 191 char *
 192 ev_page_cache_get_title (EvPageCache *page_cache)
 193 {
 194         g_return_val_if_fail (EV_IS_PAGE_CACHE (page_cache), NULL);
 195
 196         return page_cache->title;
 197 }
 198
 199 void
 200 ev_page_cache_get_size (EvPageCache *page_cache,
 201                         gint         page,
 202                         gfloat       scale,
 203                         gint        *width,
 204                         gint        *height)
 205 {
 206         g_return_if_fail (EV_IS_PAGE_CACHE (page_cache));
 207         g_return_if_fail (page > 0 && page <= page_cache->n_pages);
 208
 209         if (page_cache->uniform) {
 210                 if (width)
 211                         *width = page_cache->uniform_width;
 212                 if (height)
 213                         *height = page_cache->uniform_height;
 214         } else {
 215                 EvPageCacheInfo *info;
 216
 217                 info = &(page_cache->size_cache [page - 1]);
 218
 219                 if (width)
 220                         *width = info->width;
 221                 if (height)
 222                         *height = info->height;
 223         }
 224
 225         if (width)
 226                 *width = (*width) * scale;
 227         if (width)
 228                 *height = (*height) * scale;
 229
 230 }
 231
 232 gboolean
 233 ev_page_cache_next_page (EvPageCache *page_cache)
 234 {
 235         g_return_val_if_fail (EV_IS_PAGE_CACHE (page_cache), FALSE);
 236
 237         if (page_cache->current_page >= page_cache->n_pages)
 238                 return FALSE;
 239
 240         ev_page_cache_set_current_page (page_cache, page_cache->current_page + 1);
 241         return TRUE;
 242
 243 }
 244
 245 gboolean
 246 ev_page_cache_prev_page (EvPageCache *page_cache)
 247 {
 248         g_return_val_if_fail (EV_IS_PAGE_CACHE (page_cache), FALSE);
 249
 250         if (page_cache->current_page <= 1)
 251                 return FALSE;
 252
 253         ev_page_cache_set_current_page (page_cache, page_cache->current_page - 1);
 254         return TRUE;
 255 }
 256