Merge branch 'ulteq-simplify-zoom'

5 files changed, 60 insertions, 203 deletions

diff --git a/src/options.c b/src/options.c
index 8ddf2fa..ab9006c 100644
--- a/src/options.c
+++ b/src/options.c
@@ -592,6 +592,7 @@ static void feh_parse_option_array(int argc, char **argv, int finalrun)
 				opt.filelistfile = estrdup(optarg);
 			break;
 		case 'g':
+			opt.geom_enabled = 1;
 			opt.geom_flags = XParseGeometry(optarg, &opt.geom_x,
 					&opt.geom_y, &opt.geom_w, &opt.geom_h);
 			break;
diff --git a/src/options.h b/src/options.h
index 61de5dc..be2ca25 100644
--- a/src/options.h
+++ b/src/options.h
@@ -106,6 +106,7 @@ struct __fehoptions {
 	int sort;
 	int version_sort;
 	int debug;
+	int geom_enabled;
 	int geom_flags;
 	int geom_x;
 	int geom_y;
diff --git a/src/slideshow.c b/src/slideshow.c
index 0e560d8..b27a7e8 100644
--- a/src/slideshow.c
+++ b/src/slideshow.c
@@ -143,16 +143,6 @@ void feh_reload_image(winwidget w, int resize, int force_new)
 	Imlib_Image tmp;
 	int old_w, old_h;
 
-	unsigned char tmode =0;
-	int tim_x =0;
-	int tim_y =0;
-	double tzoom =0;
-
-	tmode = w->mode;
-	tim_x = w->im_x;
-	tim_y = w->im_y;
-	tzoom = w->zoom;
-
 	if (!w->file) {
 		im_weprintf(w, "couldn't reload, this image has no file associated with it.");
 		winwidget_render_image(w, 0, 0);
@@ -217,16 +207,7 @@ void feh_reload_image(winwidget w, int resize, int force_new)
 		w->im_w = gib_imlib_image_get_width(w->im);
 		w->im_h = gib_imlib_image_get_height(w->im);
 	}
-	if (opt.keep_zoom_vp) {
-		/* put back in: */
-		w->mode = tmode;
-		w->im_x = tim_x;
-		w->im_y = tim_y;
-		w->zoom = tzoom;
-		winwidget_render_image(w, 0, 0);
-	} else {
-		winwidget_render_image(w, resize, 0);
-	}
+	winwidget_render_image(w, resize, 0);
 
 	return;
 }
@@ -241,11 +222,6 @@ void slideshow_change_image(winwidget winwid, int change, int render)
 	 */
 	int our_filelist_len = filelist_len;
 
-	unsigned char tmode =0;
-	int tim_x =0;
-	int tim_y =0;
-	double tzoom =0;
-
 	/* Without this, clicking a one-image slideshow reloads it. Not very *
 	   intelligent behaviour :-) */
 	if (filelist_len < 2 && opt.cycle_once == 0)
@@ -356,14 +332,6 @@ void slideshow_change_image(winwidget winwid, int change, int render)
 			last = NULL;
 		}
 
-		if (opt.keep_zoom_vp) {
-		/* pre loadimage - record settings */
-			tmode = winwid->mode;
-			tim_x = winwid->im_x;
-			tim_y = winwid->im_y;
-			tzoom = winwid->zoom;
-		}
-
 		if (winwidget_loadimage(winwid, FEH_FILE(current_file->data))) {
 			int w = gib_imlib_image_get_width(winwid->im);
 			int h = gib_imlib_image_get_height(winwid->im);
@@ -378,19 +346,8 @@ void slideshow_change_image(winwidget winwid, int change, int render)
 			winwidget_reset_image(winwid);
 			winwid->im_w = w;
 			winwid->im_h = h;
-			if (opt.keep_zoom_vp) {
-				/* put back in: */
-				winwid->mode = tmode;
-				winwid->im_x = tim_x;
-				winwid->im_y = tim_y;
-				winwid->zoom = tzoom;
-			}
 			if (render) {
-				if (opt.keep_zoom_vp) {
-					winwidget_render_image(winwid, 0, 0);
-				} else {
-					winwidget_render_image(winwid, 1, 0);
-				}
+				winwidget_render_image(winwid, 1, 0);
 			}
 			break;
 		} else
diff --git a/src/winwidget.c b/src/winwidget.c
index cd5a745..e54b49e 100644
--- a/src/winwidget.c
+++ b/src/winwidget.c
@@ -323,11 +323,12 @@ void winwidget_create_window(winwidget ret, int w, int h)
 	winwidget_register(ret);
 
 	/* do not scale down a thumbnail list window, only those created from it */
-	if (opt.scale_down && (ret->type != WIN_TYPE_THUMBNAIL)) {
+	if (opt.geom_enabled && (ret->type != WIN_TYPE_THUMBNAIL)) {
 		opt.geom_w = w;
 		opt.geom_h = h;
 		opt.geom_flags |= WidthValue | HeightValue;
 	}
+
 	return;
 }
 
@@ -422,165 +423,66 @@ void winwidget_render_image(winwidget winwid, int resize, int force_alias)
 	int sx, sy, sw, sh, dx, dy, dw, dh;
 	int calc_w, calc_h;
 	int antialias = 0;
-	int need_center = winwid->had_resize;
 
 	if (!winwid->full_screen && resize) {
 		winwidget_resize(winwid, winwid->im_w, winwid->im_h, 0);
 		winwidget_reset_image(winwid);
 	}
 
-	/* bounds checks for panning */
-	if (winwid->im_x > winwid->w)
-		winwid->im_x = winwid->w;
-	if (winwid->im_y > winwid->h)
-		winwid->im_y = winwid->h;
-
 	D(("winwidget_render_image resize %d force_alias %d im %dx%d\n",
 	      resize, force_alias, winwid->im_w, winwid->im_h));
 
-	winwidget_setup_pixmaps(winwid);
-
-	if (!winwid->full_screen && ((gib_imlib_image_has_alpha(winwid->im))
-				     || (opt.geom_flags & (WidthValue | HeightValue))
-				     || (winwid->im_x || winwid->im_y) || (winwid->zoom != 1.0)
-				     || (winwid->w > winwid->im_w || winwid->h > winwid->im_h)
-				     || (winwid->has_rotated)))
-		feh_draw_checks(winwid);
-
-	if (!winwid->full_screen && opt.zoom_mode && (winwid->type != WIN_TYPE_THUMBNAIL)
-				&& (winwid->zoom == 1.0) && ! (opt.geom_flags & (WidthValue | HeightValue))
-				&& (winwid->w > winwid->im_w) && (winwid->h > winwid->im_h))
-		feh_calc_needed_zoom(&(winwid->zoom), winwid->im_w, winwid->im_h, winwid->w, winwid->h);
+	/* winwidget_setup_pixmaps(winwid) resets the winwid->had_resize flag */
+	int had_resize = winwid->had_resize || resize;
 
-	/*
-	 * In case of a resize, the geomflags (and im_w, im_h) get updated by
-	 * the ConfigureNotify handler.
-	 */
-	if (need_center && !winwid->full_screen && (winwid->type != WIN_TYPE_THUMBNAIL)
-				&& (opt.geom_flags & (WidthValue | HeightValue))
-				&& ((winwid->w < winwid->im_w) || (winwid->h < winwid->im_h)))
-		feh_calc_needed_zoom(&(winwid->zoom), winwid->im_w, winwid->im_h, winwid->w, winwid->h);
-
-
-	if (resize && (winwid->type != WIN_TYPE_THUMBNAIL) &&
-			(winwid->full_screen || (opt.geom_flags & (WidthValue | HeightValue)))) {
-		int smaller;	/* Is the image smaller than screen? */
-		int max_w = 0, max_h = 0;
+	winwidget_setup_pixmaps(winwid);
 
-		if (winwid->full_screen) {
-			max_w = scr->width;
-			max_h = scr->height;
-#ifdef HAVE_LIBXINERAMA
-			if (opt.xinerama && xinerama_screens) {
-				max_w = xinerama_screens[xinerama_screen].width;
-				max_h = xinerama_screens[xinerama_screen].height;
-			}
-#endif				/* HAVE_LIBXINERAMA */
-		} else {
-			if (opt.geom_flags & WidthValue) {
-				max_w = opt.geom_w;
-			}
-			if (opt.geom_flags & HeightValue) {
-				max_h = opt.geom_h;
-			}
-		}
+	if (had_resize && !opt.keep_zoom_vp && (winwid->type != WIN_TYPE_THUMBNAIL)) {
+		double required_zoom = 1.0;
+		feh_calc_needed_zoom(&required_zoom, winwid->im_w, winwid->im_h, winwid->w, winwid->h);
 
-		D(("Calculating for fullscreen/fixed geom render\n"));
-		smaller = ((winwid->im_w < max_w)
-			   && (winwid->im_h < max_h));
-
-		if (!smaller || opt.zoom_mode) {
-			/* contributed by Jens Laas <jens.laas@data.slu.se>
-			 * What it does:
-			 * zooms images by a fixed amount but never larger than the screen.
-			 *
-			 * Why:
-			 * This is nice if you got a collection of images where some
-			 * are small and can stand a small zoom. Large images are unaffected.
-			 *
-			 * When does it work, and how?
-			 * You have to be in fullscreen mode _and_ have auto-zoom turned on.
-			 *   "feh -FZ --zoom 130 imagefile" will do the trick.
-			 *        -zoom percent - the new switch.
-			 *                        100 = orignal size,
-			 *                        130 is 30% larger.
-			 */
-			if (opt.default_zoom) {
-				double old_zoom = winwid->zoom;
-
-				winwid->zoom = 0.01 * opt.default_zoom;
-				if (opt.default_zoom != 100) {
-					if ((winwid->im_h * winwid->zoom) > max_h)
-						winwid->zoom = old_zoom;
-					else if ((winwid->im_w * winwid->zoom) > max_w)
-						winwid->zoom = old_zoom;
-				}
+		winwid->zoom = opt.default_zoom ? (0.01 * opt.default_zoom) : 1.0;
 
-				winwid->im_x = ((int)
-						(max_w - (winwid->im_w * winwid->zoom))) >> 1;
-				winwid->im_y = ((int)
-						(max_h - (winwid->im_h * winwid->zoom))) >> 1;
-			} else {
-				/* Image is larger than the screen (so wants shrinking), or it's
-				   smaller but wants expanding to fill it */
-				double ratio = feh_calc_needed_zoom(&(winwid->zoom), winwid->im_w, winwid->im_h, max_w, max_h);
-
-				if (ratio > 1.0) {
-					/* height is the factor */
-					winwid->im_x = 0;
-					winwid->im_y = ((int)
-							(max_h - (winwid->im_h * winwid->zoom))) >> 1;
-				} else {
-					/* width is the factor */
-					winwid->im_x = ((int)
-							(max_w - (winwid->im_w * winwid->zoom))) >> 1;
-					winwid->im_y = 0;
-				}
-			}
-		} else {
-			/* my modification to jens hack, allow --zoom without auto-zoom mode */
-			if (opt.default_zoom) {
-				winwid->zoom = 0.01 * opt.default_zoom;
-			} else {
-				winwid->zoom = 1.0;
-			}
-			/* Just center the image in the window */
-			winwid->im_x = (int) (max_w - (winwid->im_w * winwid->zoom)) >> 1;
-			winwid->im_y = (int) (max_h - (winwid->im_h * winwid->zoom)) >> 1;
-		}
-	}
-	else if (need_center && !winwid->full_screen
-			&& (winwid->type != WIN_TYPE_THUMBNAIL) && !opt.keep_zoom_vp) {
-		winwid->im_x = (int) (winwid->w - (winwid->im_w * winwid->zoom)) >> 1;
-		winwid->im_y = (int) (winwid->h - (winwid->im_h * winwid->zoom)) >> 1;
-	}
+		if ((opt.scale_down || (winwid->full_screen && !opt.default_zoom))
+				&& winwid->zoom > required_zoom)
+			winwid->zoom = required_zoom;
+		else if ((opt.zoom_mode && required_zoom > 1)
+				&& (!opt.default_zoom || required_zoom < winwid->zoom))
+			winwid->zoom = required_zoom;
 
-	/*
-	 * Adjust X/Y offset if the image is larger than the window and
-	 * --inner-geometry is set. This will cause odd behaviour when
-	 * zooming an already large image in --inner-geometry mode, but in most
-	 * cases this should be what the user wants. Plus, it doesn't require
-	 * fiddling around in two or three places above, so it's the best
-	 * solution considering a future refactoring of this function.
-	 */
-
-	if (need_center || resize) {
-		if ((opt.offset_flags & XValue) && (winwid->im_w * winwid->zoom) > winwid->w) {
+		if (opt.offset_flags & XValue) {
 			if (opt.offset_flags & XNegative) {
 				winwid->im_x = winwid->w - (winwid->im_w * winwid->zoom) - opt.offset_x;
 			} else {
 				winwid->im_x = - opt.offset_x * winwid->zoom;
 			}
+		} else {
+			winwid->im_x = (int) (winwid->w - (winwid->im_w * winwid->zoom)) >> 1;
 		}
-		if ((opt.offset_flags & YValue) && (winwid->im_h * winwid->zoom) > winwid->h) {
+		if (opt.offset_flags & YValue) {
 			if (opt.offset_flags & YNegative) {
 				winwid->im_y = winwid->h - (winwid->im_h * winwid->zoom) - opt.offset_y;
 			} else {
 				winwid->im_y = - opt.offset_y * winwid->zoom;
 			}
+		} else {
+			winwid->im_y = (int) (winwid->h - (winwid->im_h * winwid->zoom)) >> 1;
 		}
 	}
 
+	winwid->had_resize = 0;
+
+	if (opt.keep_zoom_vp)
+		winwidget_sanitise_offsets(winwid);
+
+	if (!winwid->full_screen && ((gib_imlib_image_has_alpha(winwid->im))
+				     || (opt.geom_flags & (WidthValue | HeightValue))
+				     || (winwid->im_x || winwid->im_y)
+				     || (winwid->w > winwid->im_w * winwid->zoom)
+				     || (winwid->h > winwid->im_h * winwid->zoom)
+				     || (winwid->has_rotated)))
+		feh_draw_checks(winwid);
+
 	/* Now we ensure only to render the area we're looking at */
 	dx = winwid->im_x;
 	dy = winwid->im_y;
@@ -732,13 +634,6 @@ Pixmap feh_create_checks(void)
 	return(checks_pmap);
 }
 
-void winwidget_clear_background(winwidget w)
-{
-	XSetWindowBackgroundPixmap(disp, w->win, feh_create_checks());
-	/* XClearWindow(disp, w->win); */
-	return;
-}
-
 void feh_draw_checks(winwidget win)
 {
 	static GC gc = None;
@@ -898,24 +793,26 @@ void winwidget_resize(winwidget winwid, int w, int h, int force_resize)
 	D(("   x %d y %d w %d h %d\n", attributes.x, attributes.y, winwid->w,
 		winwid->h));
 
-    if ((opt.geom_flags & (WidthValue | HeightValue)) && !force_resize) {
-        winwid->had_resize = 1;
-        return;
-    }
+	if ((opt.geom_flags & (WidthValue | HeightValue)) && !force_resize) {
+		winwid->had_resize = 1;
+		return;
+	}
 	if (winwid && ((winwid->w != w) || (winwid->h != h))) {
-		/* winwidget_clear_background(winwid); */
 		if (opt.screen_clip) {
-            winwid->w = (w > scr_width) ? scr_width : w;
-            winwid->h = (h > scr_height) ? scr_height : h;
+			double required_zoom = 1.0;
+			int max_w = (w > scr_width) ? scr_width : w;
+			int max_h = (h > scr_height) ? scr_height : h;
+			feh_calc_needed_zoom(&required_zoom, winwid->im_w, winwid->im_h, max_w, max_h);
+			winwid->w = winwid->im_w * required_zoom;
+			winwid->h = winwid->im_h * required_zoom;
 		}
 		if (winwid->full_screen) {
-            XTranslateCoordinates(disp, winwid->win, attributes.root,
-                        -attributes.border_width -
-                        attributes.x,
-                        -attributes.border_width - attributes.y, &tc_x, &tc_y, &dw);
-            winwid->x = tc_x;
-            winwid->y = tc_y;
-            XMoveResizeWindow(disp, winwid->win, tc_x, tc_y, winwid->w, winwid->h);
+			XTranslateCoordinates(disp, winwid->win, attributes.root,
+						-attributes.border_width - attributes.x,
+						-attributes.border_width - attributes.y, &tc_x, &tc_y, &dw);
+			winwid->x = tc_x;
+			winwid->y = tc_y;
+			XMoveResizeWindow(disp, winwid->win, tc_x, tc_y, winwid->w, winwid->h);
 		} else
 			XResizeWindow(disp, winwid->win, winwid->w, winwid->h);
 
@@ -1043,10 +940,12 @@ void feh_debug_print_winwid(winwidget w)
 
 void winwidget_reset_image(winwidget winwid)
 {
-	winwid->zoom = 1.0;
-	winwid->old_zoom = 1.0;
-	winwid->im_x = 0;
-	winwid->im_y = 0;
+	if (!opt.keep_zoom_vp) {
+		winwid->zoom = 1.0;
+		winwid->old_zoom = 1.0;
+		winwid->im_x = 0;
+		winwid->im_y = 0;
+	}
 	winwid->im_angle = 0.0;
 	winwid->has_rotated = 0;
 	return;
diff --git a/src/winwidget.h b/src/winwidget.h
index 3d998b4..0a707ac 100644
--- a/src/winwidget.h
+++ b/src/winwidget.h
@@ -146,7 +146,6 @@ winwidget winwidget_create_from_image(Imlib_Image im, char type);
 void winwidget_rename(winwidget winwid, char *newname);
 void winwidget_destroy(winwidget winwid);
 void winwidget_create_window(winwidget ret, int w, int h);
-void winwidget_clear_background(winwidget w);
 Pixmap feh_create_checks(void);
 double feh_calc_needed_zoom(double *zoom, int orig_w, int orig_h, int dest_w, int dest_h);
 void feh_debug_print_winwid(winwidget winwid);