implemented presentation mode

This is first version of presentation mode. It basically works
but the current caching and preload algorithms do not work well
with it.

diff --git a/src/fullscreen.c b/src/fullscreen.c
index b90e895..21dc4f4 100644 (file)
--- a/src/fullscreen.c
+++ b/src/fullscreen.c
@@ -211,7 +211,6 @@ FullScreenData *fullscreen_start(GtkWidget *window, ImageWindow *imd,
 {
        FullScreenData *fs;
        GdkScreen *screen;
-       gboolean same;
        gint x, y;
        gint w, h;
        GdkGeometry geometry;
@@ -231,7 +230,7 @@ FullScreenData *fullscreen_start(GtkWidget *window, ImageWindow *imd,
 
        DEBUG_1("full screen requests screen %d", options->fullscreen.screen);
        fullscreen_prefs_get_geometry(options->fullscreen.screen, window, &x, &y, &w, &h,
-                                     &screen, &same);
+                                     &screen, &fs->same_region);
 
        fs->window = window_new(GTK_WINDOW_TOPLEVEL, "fullscreen", NULL, NULL, _("Full screen"));
 
@@ -300,7 +299,16 @@ FullScreenData *fullscreen_start(GtkWidget *window, ImageWindow *imd,
 
        gtk_widget_show(fs->imd->widget);
 
-       image_change_from_image(fs->imd, fs->normal_imd);
+       if (fs->same_region)
+               {
+               DEBUG_0("Original vindow is not visible, enabling std. fullscreen mode");
+               image_move_from_image(fs->imd, fs->normal_imd);
+               }
+       else
+               {
+               DEBUG_0("Original vindow is still visible, enabling presentation fullscreen mode");
+               image_copy_from_image(fs->imd, fs->normal_imd);
+               }
 
        if (options->stereo.enable_fsmode) {
                image_stereo_set(fs->imd, options->stereo.fsmode);
@@ -319,10 +327,13 @@ FullScreenData *fullscreen_start(GtkWidget *window, ImageWindow *imd,
        /* hide normal window
         * FIXME: properly restore this window on show
         */
+       if (fs->same_region)
+               {
 #ifdef HIDE_WINDOW_IN_FULLSCREEN
-       gtk_widget_hide(fs->normal_window);
+               gtk_widget_hide(fs->normal_window);
 #endif
-       image_change_fd(fs->normal_imd, NULL, image_zoom_get(fs->normal_imd));
+               image_change_fd(fs->normal_imd, NULL, image_zoom_get(fs->normal_imd));
+               }
 
        return fs;
 }
@@ -337,15 +348,19 @@ void fullscreen_stop(FullScreenData *fs)
        fullscreen_busy_mouse_disable(fs);
        gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 
-       image_change_from_image(fs->normal_imd, fs->imd);
-
-       if (options->stereo.enable_fsmode) {
-               image_stereo_set(fs->normal_imd, options->stereo.mode);
-       }
-
+       if (fs->same_region)
+               {
+               image_move_from_image(fs->normal_imd, fs->imd);
 #ifdef HIDE_WINDOW_IN_FULLSCREEN
-       gtk_widget_show(fs->normal_window);
+               gtk_widget_show(fs->normal_window);
 #endif
+               if (options->stereo.enable_fsmode) 
+                       {
+                       image_stereo_set(fs->normal_imd, options->stereo.mode);
+                       }
+               }
+
+
        if (fs->stop_func) fs->stop_func(fs, fs->stop_data);
 
        gtk_widget_destroy(fs->window);

diff --git a/src/image.c b/src/image.c
index b6a91bf..425a6c9 100644 (file)
--- a/src/image.c
+++ b/src/image.c
@@ -1166,7 +1166,7 @@ static void image_loader_sync_data(ImageLoader *il, gpointer old_data, gpointer
 /* this is more like a move function
  * it moves most data from source to imd
  */
-void image_change_from_image(ImageWindow *imd, ImageWindow *source)
+void image_move_from_image(ImageWindow *imd, ImageWindow *source)
 {
        if (imd == source) return;
 
@@ -1192,6 +1192,60 @@ void image_change_from_image(ImageWindow *imd, ImageWindow *source)
                source->delay_alter_type = ALTER_NONE;
                }
 
+       imd->color_profile_enable = source->color_profile_enable;
+       imd->color_profile_input = source->color_profile_input;
+       imd->color_profile_use_image = source->color_profile_use_image;
+       color_man_free((ColorMan *)imd->cm);
+       imd->cm = NULL;
+#if 0
+       if (source->cm)
+               {
+               ColorMan *cm;
+
+               imd->cm = source->cm;
+               source->cm = NULL;
+
+               cm = (ColorMan *)imd->cm;
+               cm->imd = imd;
+               cm->func_done_data = imd;
+               }
+#endif
+
+       file_data_unref(imd->read_ahead_fd);
+       source->read_ahead_fd = NULL;
+
+       imd->orientation = source->orientation;
+       imd->desaturate = source->desaturate;
+
+       imd->user_stereo = source->user_stereo;
+
+       pixbuf_renderer_move(PIXBUF_RENDERER(imd->pr), PIXBUF_RENDERER(source->pr));
+
+       if (imd->cm || imd->desaturate)
+               pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
+       else
+               pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, NULL, NULL, TRUE);
+
+}
+
+/* this is  a copy function
+ * source stays unchanged
+ */
+void image_copy_from_image(ImageWindow *imd, ImageWindow *source)
+{
+       if (imd == source) return;
+
+       imd->unknown = source->unknown;
+
+       imd->collection = source->collection;
+       imd->collection_info = source->collection_info;
+
+       image_loader_free(imd->il);
+       imd->il = NULL;
+
+       image_set_fd(imd, image_get_fd(source));
+
+
        imd->color_profile_enable = source->color_profile_enable;
        imd->color_profile_input = source->color_profile_input;
        imd->color_profile_use_image = source->color_profile_use_image;
@@ -1227,7 +1281,7 @@ void image_change_from_image(ImageWindow *imd, ImageWindow *source)
 
        imd->user_stereo = source->user_stereo;
 
-       pixbuf_renderer_move(PIXBUF_RENDERER(imd->pr), PIXBUF_RENDERER(source->pr));
+       pixbuf_renderer_copy(PIXBUF_RENDERER(imd->pr), PIXBUF_RENDERER(source->pr));
 
        if (imd->cm || imd->desaturate)
                pixbuf_renderer_set_post_process_func((PixbufRenderer *)imd->pr, image_post_process_tile_color_cb, (gpointer) imd, (imd->cm != NULL) );
@@ -1236,6 +1290,7 @@ void image_change_from_image(ImageWindow *imd, ImageWindow *source)
 
 }
 
+
 /* manipulation */
 
 void image_area_changed(ImageWindow *imd, gint x, gint y, gint width, gint height)

diff --git a/src/image.h b/src/image.h
index 0b41d2b..4b35c4d 100644 (file)
--- a/src/image.h
+++ b/src/image.h
@@ -63,7 +63,8 @@ void image_change_fd(ImageWindow *imd, FileData *fd, gdouble zoom);
 void image_change_pixbuf(ImageWindow *imd, GdkPixbuf *pixbuf, gdouble zoom, gboolean lazy);
 void image_change_from_collection(ImageWindow *imd, CollectionData *cd, CollectInfo *info, gdouble zoom);
 CollectionData *image_get_collection(ImageWindow *imd, CollectInfo **info);
-void image_change_from_image(ImageWindow *imd, ImageWindow *source);
+void image_copy_from_image(ImageWindow *imd, ImageWindow *source);
+void image_movee_from_image(ImageWindow *imd, ImageWindow *source);
 
 gboolean image_get_image_size(ImageWindow *imd, gint *width, gint *height);
 GdkPixbuf *image_get_pixbuf(ImageWindow *imd);

diff --git a/src/layout_image.c b/src/layout_image.c
index c520942..e92dffc 100644 (file)
--- a/src/layout_image.c
+++ b/src/layout_image.c
@@ -64,7 +64,8 @@ static void layout_image_full_screen_stop_func(FullScreenData *fs, gpointer data
        LayoutWindow *lw = data;
 
        /* restore image window */
-       lw->image = fs->normal_imd;
+       if (lw->image == fs->imd)
+               lw->image = fs->normal_imd;
 
        lw->full_screen = NULL;
 }
@@ -79,7 +80,8 @@ void layout_image_full_screen_start(LayoutWindow *lw)
                                           layout_image_full_screen_stop_func, lw);
 
        /* set to new image window */
-       lw->image = lw->full_screen->imd;
+       if (lw->full_screen->same_region)
+               lw->image = lw->full_screen->imd;
 
        layout_image_set_buttons(lw);
 
@@ -100,7 +102,8 @@ void layout_image_full_screen_stop(LayoutWindow *lw)
        if (!layout_valid(&lw)) return;
        if (!lw->full_screen) return;
 
-       image_osd_copy_status(lw->image, lw->full_screen->normal_imd);
+       if (lw->image == lw->full_screen->imd)
+               image_osd_copy_status(lw->image, lw->full_screen->normal_imd);
 
        fullscreen_stop(lw->full_screen);
 
@@ -780,6 +783,11 @@ void layout_image_scroll(LayoutWindow *lw, gint x, gint y, gboolean connect_scro
 
        image_scroll(lw->image, x, y);
 
+       if (lw->full_screen && lw->image != lw->full_screen->imd)
+               {
+               image_scroll(lw->full_screen->imd, x, y); 
+               }
+
        if (!connect_scroll) return;
 
        image_get_image_size(lw->image, &width, &height);
@@ -807,6 +815,11 @@ void layout_image_zoom_adjust(LayoutWindow *lw, gdouble increment, gboolean conn
 
        image_zoom_adjust(lw->image, increment);
 
+       if (lw->full_screen && lw->image != lw->full_screen->imd)
+               {
+               image_zoom_adjust(lw->full_screen->imd, increment); 
+               }
+
        if (!connect_zoom) return;
 
        for (i = 0; i < MAX_SPLIT_IMAGES; i++)
@@ -823,6 +836,11 @@ void layout_image_zoom_adjust_at_point(LayoutWindow *lw, gdouble increment, gint
 
        image_zoom_adjust_at_point(lw->image, increment, x, y);
 
+       if (lw->full_screen && lw->image != lw->full_screen->imd)
+               {
+               image_zoom_adjust_at_point(lw->full_screen->imd, increment, x, y); 
+               }
+
        if (!connect_zoom) return;
 
        for (i = 0; i < MAX_SPLIT_IMAGES; i++)
@@ -839,6 +857,11 @@ void layout_image_zoom_set(LayoutWindow *lw, gdouble zoom, gboolean connect_zoom
 
        image_zoom_set(lw->image, zoom);
 
+       if (lw->full_screen && lw->image != lw->full_screen->imd)
+               {
+               image_zoom_set(lw->full_screen->imd, zoom); 
+               }
+
        if (!connect_zoom) return;
 
        for (i = 0; i < MAX_SPLIT_IMAGES; i++)
@@ -855,6 +878,11 @@ void layout_image_zoom_set_fill_geometry(LayoutWindow *lw, gboolean vertical, gb
 
        image_zoom_set_fill_geometry(lw->image, vertical);
 
+       if (lw->full_screen && lw->image != lw->full_screen->imd)
+               {
+               image_zoom_set_fill_geometry(lw->full_screen->imd, vertical); 
+               }
+
        if (!connect_zoom) return;
 
        for (i = 0; i < MAX_SPLIT_IMAGES; i++)
@@ -967,6 +995,12 @@ void layout_image_set_fd(LayoutWindow *lw, FileData *fd)
 
        image_change_fd(lw->image, fd, image_zoom_get_default(lw->image));
 
+       if (lw->full_screen && lw->image != lw->full_screen->imd)
+               {
+               image_change_fd(lw->full_screen->imd, fd, image_zoom_get_default(lw->full_screen->imd));
+               }
+
+
        layout_list_sync_fd(lw, fd);
        layout_image_slideshow_continue_check(lw);
        layout_bars_new_image(lw);
@@ -1460,6 +1494,22 @@ static void layout_image_drag_cb(ImageWindow *imd, GdkEventButton *event, gdoubl
 {
        gint i;
        LayoutWindow *lw = data;
+       gdouble sx, sy;
+
+       if (lw->full_screen && lw->image != lw->full_screen->imd)
+               {
+               if (event->state & GDK_CONTROL_MASK)
+                       {
+                       image_get_scroll_center(imd, &sx, &sy);
+                       }
+               else
+                       {
+                       image_get_scroll_center(lw->split_images[i], &sx, &sy);
+                       sx += dx;
+                       sy += dy;
+                       }
+               image_set_scroll_center(lw->full_screen->imd, sx, sy);
+               }
 
        if (!(event->state & GDK_SHIFT_MASK)) return;
 
@@ -1467,7 +1517,6 @@ static void layout_image_drag_cb(ImageWindow *imd, GdkEventButton *event, gdoubl
                {
                if (lw->split_images[i] && lw->split_images[i] != imd)
                        {
-                       gdouble sx, sy;
 
                        if (event->state & GDK_CONTROL_MASK)
                                {

diff --git a/src/pixbuf-renderer.c b/src/pixbuf-renderer.c
index 9df2271..7f7e493 100644 (file)
--- a/src/pixbuf-renderer.c
+++ b/src/pixbuf-renderer.c
@@ -2495,8 +2495,61 @@ void pixbuf_renderer_move(PixbufRenderer *pr, PixbufRenderer *source)
        pr->scroll_reset = scroll_reset;
 
        pixbuf_renderer_set_pixbuf(source, NULL, source->zoom);
-//     pr_queue_clear(source);
-//     pr_tile_free_all(source);
+}
+
+void pixbuf_renderer_copy(PixbufRenderer *pr, PixbufRenderer *source)
+{
+       GObject *object;
+       PixbufRendererScrollResetType scroll_reset;
+
+       g_return_if_fail(IS_PIXBUF_RENDERER(pr));
+       g_return_if_fail(IS_PIXBUF_RENDERER(source));
+
+       if (pr == source) return;
+
+       object = G_OBJECT(pr);
+
+       g_object_set(object, "zoom_min", source->zoom_min, NULL);
+       g_object_set(object, "zoom_max", source->zoom_max, NULL);
+       g_object_set(object, "loading", source->loading, NULL);
+
+       pr->complete = source->complete;
+
+       pr->x_scroll = source->x_scroll;
+       pr->y_scroll = source->y_scroll;
+       pr->x_mouse  = source->x_mouse;
+       pr->y_mouse  = source->y_mouse;
+
+       scroll_reset = pr->scroll_reset;
+       pr->scroll_reset = PR_SCROLL_RESET_NOCHANGE;
+
+       pr->orientation = source->orientation;
+       pr->stereo_data = source->stereo_data;
+
+       if (source->source_tiles_enabled)
+               {
+               pr->source_tiles_enabled = source->source_tiles_enabled;
+               pr->source_tiles_cache_size = source->source_tiles_cache_size;
+               pr->source_tile_width = source->source_tile_width;
+               pr->source_tile_height = source->source_tile_height;
+               pr->image_width = source->image_width;
+               pr->image_height = source->image_height;
+
+               pr->func_tile_request = source->func_tile_request;
+               pr->func_tile_dispose = source->func_tile_dispose;
+               pr->func_tile_data = source->func_tile_data;
+
+               pr->source_tiles = source->source_tiles;
+               source->source_tiles = NULL;
+
+               pr_zoom_sync(pr, source->zoom, PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
+               }
+       else
+               {
+               pixbuf_renderer_set_pixbuf(pr, source->pixbuf, source->zoom);
+               }
+
+       pr->scroll_reset = scroll_reset;
 }
 
 void pixbuf_renderer_area_changed(PixbufRenderer *pr, gint x, gint y, gint w, gint h)

diff --git a/src/pixbuf-renderer.h b/src/pixbuf-renderer.h
index 79a586e..bec5303 100644 (file)
--- a/src/pixbuf-renderer.h
+++ b/src/pixbuf-renderer.h
@@ -262,6 +262,7 @@ gint pixbuf_renderer_get_tiles(PixbufRenderer *pr);
 /* move image data from source to pr, source is then set to NULL image */
 
 void pixbuf_renderer_move(PixbufRenderer *pr, PixbufRenderer *source);
+void pixbuf_renderer_copy(PixbufRenderer *pr, PixbufRenderer *source);
 
 /* update region of existing image */
 

diff --git a/src/typedefs.h b/src/typedefs.h
index 1ccde47..76c7306 100644 (file)
--- a/src/typedefs.h
+++ b/src/typedefs.h
@@ -868,6 +868,8 @@ struct _FullScreenData
 
        void (*stop_func)(FullScreenData *, gpointer);
        gpointer stop_data;
+       
+       gboolean same_region; /* the returned region will overlap the current location of widget. */
 };
 
 struct _PixmapFolders