#include <gtk/gtk.h>

/* replace these with two files that actually exist,
 * initially SOURCE_FILE will wipe into DEST_FILE,
 * and it will alternate after that */
#define SOURCE_FILE    "test.png"
#define DEST_FILE    "test2.png"

typedef enum
{
    GTK_IMAGE_WIPE_LEFT = 0,
    GTK_IMAGE_WIPE_RIGHT,
    GTK_IMAGE_WIPE_UP,
    GTK_IMAGE_WIPE_DOWN,
} GtkImageWipeDirection;

typedef struct _GtkImageWipeData
{
    GtkImage *im;
    GdkPixbuf *src;
    GdkPixbuf *dest;
    GtkImageWipeDirection dir;
    GdkInterpType interp_type;
    gint steps;
} GtkImageWipeData;

gboolean _gtk_image_wipe_timeout(GtkImageWipeData *wd)
{
    GdkPixbuf *src, *dest;
    /* step is the current step that we're on */
    static gint step = 0;

    gint dest_x;
    gint dest_y;
    gint dest_width;
    gint dest_height;
    gint width;
    gint height;

    src = wd->src;
    dest = wd->dest;

    width = gdk_pixbuf_get_width(src);
    height = gdk_pixbuf_get_height(src);

    /* if we're done */
    if(step == wd->steps+1)
    {
        /* create a new pixbuf */
        dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, width, height);
        /* fill it with a 0% alpha white color */
        gdk_pixbuf_fill(dest, 0xFFFFFF00);
        /* composite the new image under our result image,
         * this is so if our new image has transparency, it won't
         * show through to the old image */
        gdk_pixbuf_composite(src, dest, 0, 0, width, height, 0, 0, 1.0, 1.0, wd->interp_type, 255);
        /* update the GtkImage */
        gtk_image_set_from_pixbuf(wd->im, dest);
        /* reset step so that this function can be called more than once */
        step = 0;
        return FALSE;
    }

    /* we use a switch-case to determine the
     * proper numbers to plug into gdk_pixbuf_composite */
    switch(wd->dir)
    {
        case GTK_IMAGE_WIPE_LEFT:
            dest_x = width - (step * ((gdouble)width / wd->steps));
            dest_y = 0;
            dest_width = width - dest_x;
            dest_height = height;
            break;
        case GTK_IMAGE_WIPE_RIGHT:
            dest_x = 0;
            dest_y = 0;
            dest_width = step * ((gdouble)width / wd->steps);
            dest_height = height;
            break;
        case GTK_IMAGE_WIPE_UP:
            dest_x = 0;
            dest_y = height - (step * ((gdouble)height / wd->steps));
            dest_width = width;
            dest_height = height - dest_y;
            break;
        case GTK_IMAGE_WIPE_DOWN:
            dest_x = 0;
            dest_y = 0;
            dest_width = width;
            dest_height = step * ((gdouble)height / wd->steps);
            break;
        default:
            return FALSE;
    }

    /* composite our partial image,
     * see URL for doc on gdk_pixbuf_composite:
     * http://library.gnome.org/devel/gdk-pixbuf/stable/gdk-pixbuf-scaling.html#gdk-pixbuf-composite */
    gdk_pixbuf_composite(src, dest, dest_x, dest_y, dest_width, dest_height, 0, 0, 1.0, 1.0, wd->interp_type, 255);
    /* update the GtkImage */
    gtk_image_set_from_pixbuf(wd->im, dest);

    /* add one to step for next time */
    step++;

    return TRUE;
}

void gtk_image_wipe(GtkImage *im, GdkPixbuf *source, GdkPixbuf *dest, gint steps, gint interval, GtkImageWipeDirection direction, GdkInterpType interp_type)
{
    guint src_id;
    GtkImageWipeData wd;
    gint w, h;

    w = gdk_pixbuf_get_width(source);
    h = gdk_pixbuf_get_height(source);

    wd.im = im;
    wd.src = source;
    /* here we ensure that the old image is the same size as the new one */
    wd.dest = gdk_pixbuf_scale_simple(dest, w, h, interp_type);
    wd.dir = direction;
    wd.interp_type = interp_type;
    wd.steps = steps;

    if(interval < 1)
        interval = 1;

    src_id = g_timeout_add(interval, (GSourceFunc)_gtk_image_wipe_timeout, (gpointer)&wd);
    do
    {
        /* make sure that the GUI is updated while we're looping */
        while(gtk_events_pending())
            gtk_main_iteration();
    /* it won't be able to find the GSource once our timeout returns FALSE,
     * it will then return NULL and this function can return */
    }while(g_main_context_find_source_by_id(NULL, src_id) != NULL);

    return;
}

void call_wipe(GtkImage *im, GtkImageWipeDirection dir)
{
    GdkPixbuf *src, *dest;
    GError *err;

    static gint state = 0;
    static gboolean running = FALSE;

    err = NULL;

    /* if we are already wiping, then don't try to wipe again */

    if(running == TRUE)
        return;

    /* state is used to change which image is src and which is dest */
    if(state == 0)
    {
        src = gdk_pixbuf_new_from_file(SOURCE_FILE, &err);
        if(err != NULL)
        {
            g_critical(err->message);
            g_error_free(err);
            return;
        }
        dest = gdk_pixbuf_new_from_file(DEST_FILE, &err);
        if(err != NULL)
        {
            g_critical(err->message);
            g_error_free(err);
            return;
        }
        state = 1;
    }
    else
    {
        dest = gdk_pixbuf_new_from_file(SOURCE_FILE, &err);
        if(err != NULL)
        {
            g_critical(err->message);
            g_error_free(err);
            return;
        }
        src = gdk_pixbuf_new_from_file(DEST_FILE, &err);
        if(err != NULL)
        {
            g_critical(err->message);
            g_error_free(err);
            return;
        }
        state = 0;
    }

    /* we're running now */
    running = TRUE;
    /* 100 is the number of steps to take in wiping,
     * the higher the steps, the smoother the wipe will be,
     * it will also be slower however */
    /* 10 is the interval of how often the timeout is called,
     * it is in milliseconds */
    gtk_image_wipe(im, src, dest, 100, 10, dir, GDK_INTERP_BILINEAR);
    /* done running */
    running = FALSE;
}

void wipe_left_cb(GtkWidget *button, GtkImage *im)
{
    call_wipe(im, GTK_IMAGE_WIPE_LEFT);
}

void wipe_right_cb(GtkWidget *button, GtkImage *im)
{
    call_wipe(im, GTK_IMAGE_WIPE_RIGHT);
}

void wipe_up_cb(GtkWidget *button, GtkImage *im)
{
    call_wipe(im, GTK_IMAGE_WIPE_UP);
}

void wipe_down_cb(GtkWidget *button, GtkImage *im)
{
    call_wipe(im, GTK_IMAGE_WIPE_DOWN);
}

int main(int argc, char **argv)
{
    GtkWidget *win;
    GtkWidget *vbox;
    GtkWidget *swin;
    GtkWidget *im;
    GtkWidget *hbox;
    GtkWidget *button;

    gtk_init(&argc, &argv);

    win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    g_signal_connect(G_OBJECT(win), "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    vbox = gtk_vbox_new(FALSE, 5);
    gtk_container_add(GTK_CONTAINER(win), vbox);
    gtk_widget_show(vbox);

    swin = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);
    gtk_widget_show(swin);

    im = gtk_image_new_from_file(DEST_FILE);
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(swin), im);
    gtk_widget_show(im);

    hbox = gtk_hbox_new(TRUE, 2);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
    gtk_widget_show(hbox);

    button = gtk_button_new_with_label("Wipe Left");
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wipe_left_cb), (gpointer)im);
    gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
    gtk_widget_show(button);

    button = gtk_button_new_with_label("Wipe Right");
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wipe_right_cb), (gpointer)im);
    gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
    gtk_widget_show(button);

    button = gtk_button_new_with_label("Wipe Up");
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wipe_up_cb), (gpointer)im);
    gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
    gtk_widget_show(button);

    button = gtk_button_new_with_label("Wipe Down");
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wipe_down_cb), (gpointer)im);
    gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
    gtk_widget_show(button);

    gtk_widget_show(win);

    gtk_main();

    return 0;
}

#include <gtk/gtk.h>
#include <stdlib.h>
#include <time.h>

typedef enum
{
    GTK_IMAGE_WIPE_LEFT = 0,
    GTK_IMAGE_WIPE_RIGHT,
    GTK_IMAGE_WIPE_UP,
    GTK_IMAGE_WIPE_DOWN,
} GtkImageWipeDirection;

typedef struct _GtkImageWipeData
{
    GtkImage *im;
    GdkPixbuf *src;
    GdkPixbuf *dest;
    GtkImageWipeDirection dir;
    GdkInterpType interp_type;
    gint steps;
} GtkImageWipeData;

static const gchar *valid_suffixes[] = {
    ".png", ".jpg", ".jpeg", ".ico", ".bmp", NULL
};

gboolean slideshow_running;
guint slideshow_id;
GList *files;

gboolean _gtk_image_wipe_timeout(GtkImageWipeData *wd)
{
    GdkPixbuf *src, *dest;
    /* step is the current step that we're on */
    static gint step = 0;

    gint dest_x;
    gint dest_y;
    gint dest_width;
    gint dest_height;
    gint width;
    gint height;

    src = wd->src;
    dest = wd->dest;

    width = gdk_pixbuf_get_width(src);
    height = gdk_pixbuf_get_height(src);

    /* if we're done */
    if(step == wd->steps+1)
    {
        /* create a new pixbuf */
        dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, width, height);
        /* fill it with a 0% alpha white color */
        gdk_pixbuf_fill(dest, 0xFFFFFF00);
        /* composite the new image under our result image,
         * this is so if our new image has transparency, it won't
         * show through to the old image */
        gdk_pixbuf_composite(src, dest, 0, 0, width, height, 0, 0, 1.0, 1.0, wd->interp_type, 255);
        /* update the GtkImage */
        gtk_image_set_from_pixbuf(wd->im, dest);
        /* reset step so that this function can be called more than once */
        step = 0;
        return FALSE;
    }

    /* we use a switch-case to determine the
     * proper numbers to plug into gdk_pixbuf_composite */
    switch(wd->dir)
    {
        case GTK_IMAGE_WIPE_LEFT:
            dest_x = width - (step * ((gdouble)width / wd->steps));
            dest_y = 0;
            dest_width = width - dest_x;
            dest_height = height;
            break;
        case GTK_IMAGE_WIPE_RIGHT:
            dest_x = 0;
            dest_y = 0;
            dest_width = step * ((gdouble)width / wd->steps);
            dest_height = height;
            break;
        case GTK_IMAGE_WIPE_UP:
            dest_x = 0;
            dest_y = height - (step * ((gdouble)height / wd->steps));
            dest_width = width;
            dest_height = height - dest_y;
            break;
        case GTK_IMAGE_WIPE_DOWN:
            dest_x = 0;
            dest_y = 0;
            dest_width = width;
            dest_height = step * ((gdouble)height / wd->steps);
            break;
        default:
            return FALSE;
    }

    /* composite our partial image,
     * see URL for doc on gdk_pixbuf_composite:
     * http://library.gnome.org/devel/gdk-pixbuf/stable/gdk-pixbuf-scaling.html#gdk-pixbuf-composite */
    gdk_pixbuf_composite(src, dest, dest_x, dest_y, dest_width, dest_height, 0, 0, 1.0, 1.0, wd->interp_type, 255);
    /* update the GtkImage */
    gtk_image_set_from_pixbuf(wd->im, dest);

    /* add one to step for next time */
    step++;

    return TRUE;
}

void gtk_image_wipe(GtkImage *im, GdkPixbuf *source, GdkPixbuf *dest, gint steps, gint interval, GtkImageWipeDirection direction, GdkInterpType interp_type)
{
    guint src_id;
    GtkImageWipeData wd;
    gint w, h;

    w = gdk_pixbuf_get_width(source);
    h = gdk_pixbuf_get_height(source);

    wd.im = im;
    wd.src = source;
    /* here we ensure that the old image is the same size as the new one */
    wd.dest = gdk_pixbuf_scale_simple(dest, w, h, interp_type);
    wd.dir = direction;
    wd.interp_type = interp_type;
    wd.steps = steps;

    if(interval < 1)
        interval = 1;

    src_id = g_timeout_add(interval, (GSourceFunc)_gtk_image_wipe_timeout, (gpointer)&wd);
    do
    {
        /* make sure that the GUI is updated while we're looping */
        while(gtk_events_pending())
            gtk_main_iteration();
    /* it won't be able to find the GSource once our timeout returns FALSE,
     * it will then return NULL and this function can return */
    }while(g_main_context_find_source_by_id(NULL, src_id) != NULL);

    return;
}

/* this function checks each item in array to see if str has it as a suffix */
gboolean g_str_has_suffix_in_array(const gchar *str, const gchar **array)
{
    gint i;

    for(i = 0; array[i] != NULL; i++)
    {
        if(g_str_has_suffix(str, array[i]))
            return TRUE;
    }
    return FALSE;
}

gboolean slideshow_timeout(GtkImage *im)
{
    GdkPixbuf *one, *two;
    gchar *oneS, *twoS;
    GError *err;

    err = NULL;

    if(files == NULL)
        return FALSE;

    if(slideshow_running == FALSE)
        return FALSE;

    if(files->next == NULL)
    {
        slideshow_running = FALSE;
        return FALSE;
    }
    oneS = (gchar*)files->data;
    twoS = (gchar*)files->next->data;

    if(files->prev != NULL)
    {
        one = gdk_pixbuf_new_from_file(oneS, &err);
        if(err != NULL)
        {
            g_warning(err->message);
            g_error_free(err);
            return TRUE;
        }
    }
    else
    {
        one = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 1, 1);
        gdk_pixbuf_fill(one, 0x00000000);
    }
    two = gdk_pixbuf_new_from_file(twoS, &err);
    if(err != NULL)
    {
        g_warning(err->message);
        g_error_free(err);
        return TRUE;
    }

    gtk_image_set_from_pixbuf(im, one);

    gtk_image_wipe(im, two, one, 100, 100, rand()%4, GDK_INTERP_BILINEAR);

    files = files->next;

    return TRUE;
}

void file_set_cb(GtkFileChooserButton *but, GtkImage *im)
{
    GDir *dir;
    GError *err;
    const gchar *item;
    gchar *path, *uri;
    gchar sep[2];

    err = NULL;

    sprintf(sep, "%c", G_DIR_SEPARATOR);

    path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(but));

    /* open the chosen directory */
    dir = g_dir_open(path, 0, &err);
    if(err != NULL)
    {
        g_warning(err->message);
        g_error_free(err);
        return;
    }

    slideshow_running = FALSE;

    if(files != NULL)
    {
        g_list_free(files);
        files = NULL;
    }

    /* get all the items in the directory */
    while((item = g_dir_read_name(dir)))
    {
        /* build a path so that we can test it with g_file_test */
        uri = g_strjoin(sep, path, item, NULL);
        /* test to make sure it's not a directory or something else */
        if(g_file_test(uri, G_FILE_TEST_IS_REGULAR))
        {
            /* if it doesn't have a valid suffix, then move on */
            if(!g_str_has_suffix_in_array(item, valid_suffixes))
                continue;
            /* if it does have a valid suffix, then add it to a list of files */
            else
                files = g_list_append(files, (gpointer)g_strdup(uri));
        }
    }

    files = g_list_first(files);

    gtk_image_set_from_file(im, (gchar*)files->data);

    srand((unsigned)time(NULL));
}

void slideshow_next_image(GtkWidget *button, GtkImage *im)
{
    GdkPixbuf *one, *two;
    gchar *oneS, *twoS;
    GError *err;

    err = NULL;

    if(files == NULL)
        return;

    if(files->next == NULL)
        return;

    oneS = (gchar*)files->data;
    twoS = (gchar*)files->next->data;

    one = gdk_pixbuf_new_from_file(oneS, &err);
    if(err != NULL)
    {
        g_warning(err->message);
        g_error_free(err);
        return;
    }
    two = gdk_pixbuf_new_from_file(twoS, &err);
    if(err != NULL)
    {
        g_warning(err->message);
        g_error_free(err);
        return;
    }

    if(slideshow_running == TRUE)
        return;
    gtk_image_set_from_pixbuf(im, one);
    slideshow_running = TRUE;
    gtk_image_wipe(im, two, one, 100, 100, rand()%4, GDK_INTERP_BILINEAR);
    slideshow_running = FALSE;

    files = files->next;
}

void slideshow_prev_image(GtkWidget *button, GtkImage *im)
{
    GdkPixbuf *one, *two;
    gchar *oneS, *twoS;
    GError *err;

    err = NULL;

    if(files == NULL)
        return;

    if(files->next == NULL || files->prev == NULL)
        return;

    oneS = (gchar*)files->data;
    twoS = (gchar*)files->prev->data;

    one = gdk_pixbuf_new_from_file(oneS, &err);
    if(err != NULL)
    {
        g_warning(err->message);
        g_error_free(err);
        return;
    }
    two = gdk_pixbuf_new_from_file(twoS, &err);
    if(err != NULL)
    {
        g_warning(err->message);
        g_error_free(err);
        return;
    }

    if(slideshow_running == TRUE)
        return;
    gtk_image_set_from_pixbuf(im, one);
    slideshow_running = TRUE;
    gtk_image_wipe(im, two, one, 100, 100, rand()%4, GDK_INTERP_BILINEAR);
    slideshow_running = FALSE;

    files = files->prev;
}

int main(int argc, char **argv)
{
    GtkWidget *win;
    GtkWidget *vbox;
    GtkWidget *button;
    GtkWidget *hbox;
    GtkWidget *swin;
    GtkWidget *im;

    slideshow_running = FALSE;
    files = NULL;

    gtk_init(&argc, &argv);

    win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    g_signal_connect(G_OBJECT(win), "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(win), vbox);
    gtk_widget_show(vbox);

    im = gtk_image_new();

    button = gtk_file_chooser_button_new("Select Folder", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
    g_signal_connect(G_OBJECT(button), "file-set", G_CALLBACK(file_set_cb), (gpointer)im);
    gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
    gtk_widget_show(button);

    hbox = gtk_hbox_new(FALSE, 2);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
    gtk_widget_show(hbox);

    button = gtk_button_new_with_label("Previous");
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(slideshow_prev_image), (gpointer)im);
    gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
    gtk_widget_show(button);

    button = gtk_button_new_with_label("Next");
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(slideshow_next_image), (gpointer)im);
    gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
    gtk_widget_show(button);

    swin = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);
    gtk_widget_show(swin);

    /* im was created earlier */
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(swin), im);
    gtk_widget_show(im);

    gtk_widget_show(win);

    gtk_main();

    return 0;
}