src/slideshow.c

   1 /*
   2  * Geeqie
   3  * (C) 2004 John Ellis
   4  *
   5  * Author: John Ellis
   6  *
   7  * This software is released under the GNU General Public License (GNU GPL).
   8  * Please read the included file COPYING for more information.
   9  * This software comes with no warranty of any kind, use at your own risk!
  10  */
  11
  12
  13 #include "main.h"
  14 #include "collect.h"
  15 #include "image.h"
  16 #include "slideshow.h"
  17 #include "filelist.h"
  18
  19 #include "layout.h"
  20 #include "layout_image.h"
  21 #include "ui_fileops.h"
  22
  23
  24 static void slideshow_timer_reset(SlideShowData *ss, gint reset);
  25
  26
  27 void slideshow_free(SlideShowData *ss)
  28 {
  29         if (!ss) return;
  30
  31         slideshow_timer_reset(ss, FALSE);
  32
  33         if (ss->stop_func) ss->stop_func(ss, ss->stop_data);
  34
  35         if (ss->filelist) filelist_free(ss->filelist);
  36         if (ss->cd) collection_unref(ss->cd);
  37         g_free(ss->layout_path);
  38
  39         g_list_free(ss->list);
  40         g_list_free(ss->list_done);
  41
  42         file_data_unref(ss->slide_fd);
  43
  44         g_free(ss);
  45 }
  46
  47 static GList *generate_list(SlideShowData *ss)
  48 {
  49         GList *list = NULL;
  50
  51         if (ss->from_selection)
  52                 {
  53                 list = layout_selection_list_by_index(ss->layout);
  54                 }
  55         else
  56                 {
  57                 gint i;
  58                 for(i = 0; i < ss->slide_count; i++)
  59                         {
  60                         list = g_list_prepend(list, GINT_TO_POINTER(i));
  61                         }
  62                 list = g_list_reverse(list);
  63                 }
  64
  65         return list;
  66 }
  67
  68 static GList *generate_random_list(SlideShowData *ss)
  69 {
  70         GList *src_list = NULL;
  71         GList *list = NULL;
  72         GList *work;
  73
  74         src_list = generate_list(ss);
  75
  76         while(src_list)
  77                 {
  78                 gint p = (double)rand() / ((double)RAND_MAX + 1.0) * g_list_length(src_list);
  79                 work = g_list_nth(src_list, p);
  80                 list = g_list_prepend(list, work->data);
  81                 src_list = g_list_remove(src_list, work->data);
  82                 }
  83
  84         return list;
  85 }
  86
  87 static void slideshow_list_init(SlideShowData *ss, gint start_index)
  88 {
  89         if (ss->list_done)
  90                 {
  91                 g_list_free(ss->list_done);
  92                 ss->list_done = NULL;
  93                 }
  94
  95         if (ss->list) g_list_free(ss->list);
  96
  97         if (slideshow_random)
  98                 {
  99                 ss->list = generate_random_list(ss);
 100                 }
 101         else
 102                 {
 103                 ss->list = generate_list(ss);
 104                 if (start_index >= 0)
 105                         {
 106                         /* start with specified image by skipping to it */
 107                         gint i = 0;
 108
 109                         while(ss->list && i < start_index)
 110                                 {
 111                                 ss->list_done = g_list_prepend (ss->list_done, ss->list->data);
 112                                 ss->list = g_list_remove(ss->list, ss->list->data);
 113                                 i++;
 114                                 }
 115                         }
 116                 }
 117 }
 118
 119 gint slideshow_should_continue(SlideShowData *ss)
 120 {
 121         FileData *imd_fd;
 122         const gchar *path;
 123
 124         if (!ss) return FALSE;
 125
 126         imd_fd = image_get_fd(ss->imd);
 127
 128         if ( ((imd_fd == NULL) != (ss->slide_fd == NULL)) ||
 129             (imd_fd && ss->slide_fd && imd_fd != ss->slide_fd) ) return FALSE;
 130
 131         if (ss->filelist) return TRUE;
 132
 133         if (ss->cd)
 134                 {
 135                 if (g_list_length(ss->cd->list) == ss->slide_count)
 136                         return TRUE;
 137                 else
 138                         return FALSE;
 139                 }
 140
 141         if (!ss->layout) return FALSE;
 142         path = layout_get_path(ss->layout);
 143
 144         if (path && ss->layout_path &&
 145             strcmp(path, ss->layout_path) == 0)
 146                 {
 147                 if (ss->from_selection && ss->slide_count == layout_selection_count(ss->layout, NULL)) return TRUE;
 148                 if (!ss->from_selection && ss->slide_count == layout_list_count(ss->layout, NULL)) return TRUE;
 149                 }
 150
 151         return FALSE;
 152 }
 153
 154 static gint slideshow_step(SlideShowData *ss, gint forward)
 155 {
 156         gint row;
 157
 158         if (!slideshow_should_continue(ss))
 159                 {
 160                 return FALSE;
 161                 }
 162
 163         if (forward)
 164                 {
 165                 if (!ss->list) return TRUE;
 166
 167                 row = GPOINTER_TO_INT(ss->list->data);
 168                 ss->list_done = g_list_prepend (ss->list_done, ss->list->data);
 169                 ss->list = g_list_remove(ss->list, ss->list->data);
 170                 }
 171         else
 172                 {
 173                 if (!ss->list_done || !ss->list_done->next) return TRUE;
 174
 175                 ss->list = g_list_prepend(ss->list, ss->list_done->data);
 176                 ss->list_done = g_list_remove(ss->list_done, ss->list_done->data);
 177                 row = GPOINTER_TO_INT(ss->list_done->data);
 178                 }
 179
 180         file_data_unref(ss->slide_fd);
 181         ss->slide_fd = NULL;
 182
 183         if (ss->filelist)
 184                 {
 185                 ss->slide_fd = file_data_ref((FileData *)g_list_nth_data(ss->filelist, row));
 186                 image_change_fd(ss->imd, ss->slide_fd, image_zoom_get_default(ss->imd, zoom_mode));
 187                 }
 188         else if (ss->cd)
 189                 {
 190                 CollectInfo *info;
 191
 192                 info = g_list_nth_data(ss->cd->list, row);
 193                 ss->slide_fd = file_data_ref(info->fd);
 194
 195                 image_change_from_collection(ss->imd, ss->cd, info, image_zoom_get_default(ss->imd, zoom_mode));
 196                 }
 197         else
 198                 {
 199                 ss->slide_fd = file_data_ref(layout_list_get_fd(ss->layout, row));
 200
 201                 if (ss->from_selection)
 202                         {
 203                         image_change_fd(ss->imd, ss->slide_fd, image_zoom_get_default(ss->imd, zoom_mode));
 204                         layout_status_update_info(ss->layout, NULL);
 205                         }
 206                 else
 207                         {
 208                         layout_image_set_index(ss->layout, row);
 209                         }
 210                 }
 211
 212         if (!ss->list && slideshow_repeat)
 213                 {
 214                 slideshow_list_init(ss, -1);
 215                 }
 216
 217         if (!ss->list)
 218                 {
 219                 return FALSE;
 220                 }
 221
 222         /* read ahead */
 223
 224         if (enable_read_ahead)
 225                 {
 226                 gint r;
 227                 if (forward)
 228                         {
 229                         if (!ss->list) return TRUE;
 230                         r = GPOINTER_TO_INT(ss->list->data);
 231                         }
 232                 else
 233                         {
 234                         if (!ss->list_done || !ss->list_done->next) return TRUE;
 235                         r = GPOINTER_TO_INT(ss->list_done->next->data);
 236                         }
 237
 238                 if (ss->filelist)
 239                         {
 240                         image_prebuffer_set(ss->imd, g_list_nth_data(ss->filelist, r));
 241                         }
 242                 else if (ss->cd)
 243                         {
 244                         CollectInfo *info;
 245                         info = g_list_nth_data(ss->cd->list, r);
 246                         if (info) image_prebuffer_set(ss->imd, info->fd);
 247                         }
 248                 else if (ss->from_selection)
 249                         {
 250                         image_prebuffer_set(ss->imd, layout_list_get_fd(ss->layout, r));
 251                         }
 252                 }
 253
 254         return TRUE;
 255 }
 256
 257 static gint slideshow_loop_cb(gpointer data)
 258 {
 259         SlideShowData *ss = data;
 260
 261         if (ss->paused) return TRUE;
 262
 263         if (!slideshow_step(ss, TRUE))
 264                 {
 265                 ss->timeout_id = -1;
 266                 slideshow_free(ss);
 267                 return FALSE;
 268                 }
 269
 270         return TRUE;
 271 }
 272
 273 static void slideshow_timer_reset(SlideShowData *ss, gint reset)
 274 {
 275         if (reset)
 276                 {
 277                 if (slideshow_delay < 1) slideshow_delay = 1;
 278
 279                 if (ss->timeout_id != -1) g_source_remove(ss->timeout_id);
 280                 ss->timeout_id = g_timeout_add(slideshow_delay * 1000 / SLIDESHOW_SUBSECOND_PRECISION,
 281                                                slideshow_loop_cb, ss);
 282                 }
 283         else if (ss->timeout_id != -1)
 284                 {
 285                 g_source_remove(ss->timeout_id);
 286                 ss->timeout_id = -1;
 287                 }
 288 }
 289
 290 void slideshow_next(SlideShowData *ss)
 291 {
 292         if (!ss) return;
 293
 294         if (!slideshow_step(ss, TRUE))
 295                 {
 296                 slideshow_free(ss);
 297                 return;
 298                 }
 299
 300         slideshow_timer_reset(ss, TRUE);
 301 }
 302
 303 void slideshow_prev(SlideShowData *ss)
 304 {
 305         if (!ss) return;
 306
 307         if (!slideshow_step(ss, FALSE))
 308                 {
 309                 slideshow_free(ss);
 310                 return;
 311                 }
 312
 313         slideshow_timer_reset(ss, TRUE);
 314 }
 315
 316 static SlideShowData *real_slideshow_start(ImageWindow *imd, LayoutWindow *lw,
 317                                            GList *filelist, gint start_point,
 318                                            CollectionData *cd, CollectInfo *start_info,
 319                                            void (*stop_func)(SlideShowData *, gpointer), gpointer stop_data)
 320 {
 321         SlideShowData *ss;
 322         gint start_index = -1;
 323
 324         if (!filelist && !cd && layout_list_count(lw, NULL) < 1) return NULL;
 325
 326         ss = g_new0(SlideShowData, 1);
 327
 328         ss->imd = imd;
 329
 330         ss->filelist = filelist;
 331         ss->cd = cd;
 332         ss->layout = lw;
 333         ss->layout_path = NULL;
 334
 335         ss->list = NULL;
 336         ss->list_done = NULL;
 337
 338         ss->from_selection = FALSE;
 339
 340         ss->stop_func = NULL;
 341
 342         ss->timeout_id = -1;
 343         ss->paused = FALSE;
 344
 345         if (ss->filelist)
 346                 {
 347                 ss->slide_count = g_list_length(ss->filelist);
 348                 }
 349         else if (ss->cd)
 350                 {
 351                 collection_ref(ss->cd);
 352                 ss->slide_count = g_list_length(ss->cd->list);
 353                 if (!slideshow_random && start_info)
 354                         {
 355                         start_index = g_list_index(ss->cd->list, start_info);
 356                         }
 357                 }
 358         else
 359                 {
 360                 /* layout method */
 361
 362                 ss->slide_count = layout_selection_count(ss->layout, NULL);
 363                 ss->layout_path = g_strdup(layout_get_path(ss->layout));
 364                 if (ss->slide_count < 2)
 365                         {
 366                         ss->slide_count = layout_list_count(ss->layout, NULL);
 367                         if (!slideshow_random && start_point >= 0 && start_point < ss->slide_count)
 368                                 {
 369                                 start_index = start_point;
 370                                 }
 371                         }
 372                 else
 373                         {
 374                         ss->from_selection = TRUE;
 375                         }
 376                 }
 377
 378         slideshow_list_init(ss, start_index);
 379
 380         ss->slide_fd = file_data_ref(image_get_fd(ss->imd));
 381         if (slideshow_step(ss, TRUE))
 382                 {
 383                 slideshow_timer_reset(ss, TRUE);
 384
 385                 ss->stop_func = stop_func;
 386                 ss->stop_data = stop_data;
 387                 }
 388         else
 389                 {
 390                 slideshow_free(ss);
 391                 ss = NULL;
 392                 }
 393
 394         return ss;
 395 }
 396
 397 SlideShowData *slideshow_start_from_filelist(ImageWindow *imd, GList *list,
 398                                               void (*stop_func)(SlideShowData *, gpointer), gpointer stop_data)
 399 {
 400         return real_slideshow_start(imd, NULL, list, -1, NULL, NULL, stop_func, stop_data);
 401 }
 402
 403 SlideShowData *slideshow_start_from_collection(ImageWindow *imd, CollectionData *cd,
 404                                                void (*stop_func)(SlideShowData *, gpointer), gpointer stop_data,
 405                                                CollectInfo *start_info)
 406 {
 407         return real_slideshow_start(imd, NULL, NULL, -1, cd, start_info, stop_func, stop_data);
 408 }
 409
 410 SlideShowData *slideshow_start(ImageWindow *imd, LayoutWindow *lw, gint start_point,
 411                                void (*stop_func)(SlideShowData *, gpointer), gpointer stop_data)
 412 {
 413         return real_slideshow_start(imd, lw, NULL, start_point, NULL, NULL, stop_func, stop_data);
 414 }
 415
 416 gint slideshow_paused(SlideShowData *ss)
 417 {
 418         if (!ss) return FALSE;
 419
 420         return ss->paused;
 421 }
 422
 423 void slideshow_pause_set(SlideShowData *ss, gint paused)
 424 {
 425         if (!ss) return;
 426
 427         ss->paused = paused;
 428 }
 429
 430 gint slideshow_pause_toggle(SlideShowData *ss)
 431 {
 432         slideshow_pause_set(ss, !slideshow_paused(ss));
 433         return slideshow_paused(ss);
 434 }
 435
 436