Merge branch 'ulteq-simplify-zoom' (56c34520) · Commits · derf / feh

src/options.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -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;

src/options.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -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;

src/slideshow.c

+2 −45

Original line number	Diff line number	Diff line
		@@ -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);
		}

		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,20 +346,9 @@ 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);
		}
		}
		break;
		} else
		last = current_file;

src/winwidget.c

+56 −157

Original line number	Diff line number	Diff line
		@@ -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);
		/* winwidget_setup_pixmaps(winwid) resets the winwid->had_resize flag */
		int had_resize = winwid->had_resize \|\| resize;

		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);

		/*
		* 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;
		}
		}

		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;
		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);

		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 ((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;

		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;
		}

		/*
		* 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;
		@@ -903,15 +798,17 @@ void winwidget_resize(winwidget winwid, int w, int h, int force_resize)
		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.x,
		-attributes.border_width - attributes.y, &tc_x, &tc_y, &dw);
		winwid->x = tc_x;
		winwid->y = tc_y;
		@@ -1043,10 +940,12 @@ void feh_debug_print_winwid(winwidget w)

		void winwidget_reset_image(winwidget winwid)
		{
		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;

src/winwidget.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -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);

Admin message