Commit 3724d3f

nsxiv3724d3f

Revised autoreload interface

Make the header only contain the public interface and nothing from the
implementation. All functions get a handle to their self object, like the img_
and tns_ and win_ functions. All necessary data (file path) is also passed as
an argument, so that no extern redeclarations are needed.

Make arl_setup_dir() private, it's not called outside the module.

Make arl_handle() return true if the file has changed, so that the reloading of
the file can be done by the caller.

Author: Bert Münnich
Date: 2017-05-17 20:07 +0200
Parent: edb117e
Commit: 3724d3fc17dc6135a05608cab5bdf00c6978282d

+100 −91

4 files changed

Browse files Patch

−Context 3+

M autoreload.h +5 −13
M autoreload_inotify.c +53 −57
M autoreload_nop.c +22 −10
M main.c +20 −11

M autoreload.h View

M autoreload_inotify.c View

M autoreload_nop.c View

M main.c View

		@@ -21,23 +21,15 @@
21	21
22	22		#include "types.h"
23	23
24		−	void arl_cleanup(void);
25		−	void arl_handle(void);
26		−	void arl_init(void);
27		−	void arl_setup(void);
28		−	void arl_setup_dir(void);
29		−
30	24		typedef struct {
31	25		int fd;
32	26		int wd;
33	27		bool watching_dir;
34		−	} autoreload_t;
35		−
36		−	extern autoreload_t autoreload;
37		−	extern int fileidx;
38		−	extern fileinfo_t *files;
	28	+	} arl_t;
39	29
40		−	void load_image(int);
41		−	void redraw(void);
	30	+	void arl_cleanup(arl_t*);
	31	+	bool arl_handle(arl_t, const char);
	32	+	void arl_init(arl_t*);
	33	+	void arl_setup(arl_t, const char);
42	34
43	35		#endif /* AUTORELOAD_H */

		@@ -21,35 +21,59 @@
21	21		#include <unistd.h>
22	22		#include <sys/inotify.h>
23	23		#include <libgen.h>
24		−	#include <time.h>
25	24
26	25		#include "util.h"
27	26		#include "autoreload.h"
28	27
29		−	const struct timespec ten_ms = {0, 10000000};
30		−
31		−	void arl_cleanup(void)
	28	+	CLEANUP void arl_cleanup(arl_t *arl)
32	29		{
33		−	if (autoreload.fd != -1 && autoreload.wd != -1)
	30	+	if (arl->fd != -1 && arl->wd != -1)
34	31		{
35		−	if(inotify_rm_watch(autoreload.fd, autoreload.wd))
	32	+	if(inotify_rm_watch(arl->fd, arl->wd))
36	33		error(0, 0, "Failed to remove inotify watch.");
37	34		}
38	35		}
39	36
40		−	void arl_handle(void)
	37	+	static void arl_setup_dir(arl_t arl, const char filepath)
	38	+	{
	39	+	char dntmp, dn;
	40	+
	41	+	if (arl->fd == -1)
	42	+	{
	43	+	error(0, 0, "Uninitialized, could not add inotify watch on directory.");
	44	+	return;
	45	+	}
	46	+
	47	+	/* get dirname */
	48	+	dntmp = (char*) strdup(filepath);
	49	+	dn = (char*) dirname(dntmp);
	50	+
	51	+	/* this is not one-shot as other stuff may be created too
	52	+	note: we won't handle deletion of the directory itself,
	53	+	this is a design decision */
	54	+	arl->wd = inotify_add_watch(arl->fd, dn,IN_CREATE);
	55	+	if (arl->wd == -1)
	56	+	error(0, 0, "Failed to add inotify watch on directory '%s'.", dn);
	57	+	else
	58	+	arl->watching_dir = true;
	59	+
	60	+	free(dntmp);
	61	+	}
	62	+
	63	+	bool arl_handle(arl_t arl, const char filepath)
41	64		{
	65	+	bool reload = false;
42	66		ssize_t len;
43	67		char buf[4096] __attribute__ ((aligned(__alignof__(struct inotify_event))));
44	68		const struct inotify_event *event;
45	69		char *ptr;
46	70		char fntmp, fn;
47	71
48		−	len = read(autoreload.fd, buf, sizeof buf);
	72	+	len = read(arl->fd, buf, sizeof buf);
49	73		if (len == -1)
50	74		{
51	75		error(0, 0, "Failed to read inotify events.");
52		−	return;
	76	+	return false;
53	77		}
54	78
55	79		for (ptr = buf; ptr < buf + len;
		@@ -61,17 +85,16 @@ void arl_handle(void)
61	85		/* events from watching the file itself */
62	86		if (event->mask & IN_CLOSE_WRITE)
63	87		{
64		−	load_image(fileidx);
65		−	redraw();
	88	+	reload = true;
66	89		}
67	90
68	91		if (event->mask & IN_DELETE_SELF)
69		−	arl_setup_dir();
	92	+	arl_setup_dir(arl, filepath);
70	93
71	94		/* events from watching the file's directory */
72	95		if (event->mask & IN_CREATE)
73	96		{
74		−	fntmp = strdup(files[fileidx].path);
	97	+	fntmp = strdup(filepath);
75	98		fn = basename(fntmp);
76	99
77	100		if (0 == strcmp(event->name, fn))
		@@ -79,76 +102,49 @@ void arl_handle(void)
79	102		/* this is the file we're looking for */
80	103
81	104		/* cleanup, this has not been one-shot */
82		−	if (autoreload.watching_dir)
	105	+	if (arl->watching_dir)
83	106		{
84		−	if(inotify_rm_watch(autoreload.fd, autoreload.wd))
	107	+	if(inotify_rm_watch(arl->fd, arl->wd))
85	108		error(0, 0, "Failed to remove inotify watch.");
86		−	autoreload.watching_dir = false;
	109	+	arl->watching_dir = false;
87	110		}
88	111
89		−	/* when too fast, imlib2 can't load the image */
90		−	nanosleep(&ten_ms, NULL);
91		−	load_image(fileidx);
92		−	redraw();
	112	+	reload = true;
93	113		}
94	114		free(fntmp);
95	115		}
96	116		}
	117	+	return reload;
97	118		}
98	119
99		−	void arl_init(void)
	120	+	void arl_init(arl_t *arl)
100	121		{
101	122		/* this needs to be done only once */
102		−	autoreload.fd = inotify_init();
103		−	autoreload.watching_dir = false;
104		−	if (autoreload.fd == -1)
	123	+	arl->fd = inotify_init();
	124	+	arl->watching_dir = false;
	125	+	if (arl->fd == -1)
105	126		error(0, 0, "Could not initialize inotify.");
106	127		}
107	128
108		−	void arl_setup(void)
	129	+	void arl_setup(arl_t arl, const char filepath)
109	130		{
110		−	if (autoreload.fd == -1)
	131	+	if (arl->fd == -1)
111	132		{
112	133		error(0, 0, "Uninitialized, could not add inotify watch.");
113	134		return;
114	135		}
115	136
116	137		/* may have switched from a deleted to another image */
117		−	if (autoreload.watching_dir)
	138	+	if (arl->watching_dir)
118	139		{
119		−	if (inotify_rm_watch(autoreload.fd, autoreload.wd))
	140	+	if (inotify_rm_watch(arl->fd, arl->wd))
120	141		error(0, 0, "Failed to remove inotify watch.");
121		−	autoreload.watching_dir = false;
	142	+	arl->watching_dir = false;
122	143		}
123	144
124		−	autoreload.wd = inotify_add_watch(autoreload.fd, files[fileidx].path,
	145	+	arl->wd = inotify_add_watch(arl->fd, filepath,
125	146		IN_ONESHOT \| IN_CLOSE_WRITE \| IN_DELETE_SELF);
126		−	if (autoreload.wd == -1)
127		−	error(0, 0, "Failed to add inotify watch on file '%s'.", files[fileidx].path);
	147	+	if (arl->wd == -1)
	148	+	error(0, 0, "Failed to add inotify watch on file '%s'.", filepath);
128	149		}
129	150
130		−	void arl_setup_dir(void)
131		−	{
132		−	char dntmp, dn;
133		−
134		−	if (autoreload.fd == -1)
135		−	{
136		−	error(0, 0, "Uninitialized, could not add inotify watch on directory.");
137		−	return;
138		−	}
139		−
140		−	/* get dirname */
141		−	dntmp = (char*) strdup(files[fileidx].path);
142		−	dn = (char*) dirname(dntmp);
143		−
144		−	/* this is not one-shot as other stuff may be created too
145		−	note: we won't handle deletion of the directory itself,
146		−	this is a design decision */
147		−	autoreload.wd = inotify_add_watch(autoreload.fd, dn,IN_CREATE);
148		−	if (autoreload.wd == -1)
149		−	error(0, 0, "Failed to add inotify watch on directory '%s'.", dn);
150		−	else
151		−	autoreload.watching_dir = true;
152		−
153		−	free(dntmp);
154		−	}

		@@ -18,14 +18,26 @@
18	18
19	19		#include "autoreload.h"
20	20
21		−	void arl_cleanup(void) { }
22		−
23		−	void arl_handle(void) { }
24		−
25		−	void arl_init(void) { }
26		−
27		−	void arl_setup(void) { }
28		−
29		−	void arl_setup_dir(void) { }
30		−
	21	+	void arl_cleanup(arl_t *arl)
	22	+	{
	23	+	(void) arl;
	24	+	}
	25	+
	26	+	bool arl_handle(arl_t arl, const char filepath)
	27	+	{
	28	+	(void) arl;
	29	+	(void) filepath;
	30	+	return false;
	31	+	}
	32	+
	33	+	void arl_init(arl_t *arl)
	34	+	{
	35	+	(void) arl;
	36	+	}
	37	+
	38	+	void arl_setup(arl_t arl, const char filepath)
	39	+	{
	40	+	(void) arl;
	41	+	(void) filepath;
	42	+	}
31	43

		@@ -28,6 +28,7 @@
28	28		#include <sys/stat.h>
29	29		#include <sys/time.h>
30	30		#include <sys/wait.h>
	31	+	#include <time.h>
31	32		#include <X11/keysym.h>
32	33		#include <X11/XF86keysym.h>
33	34
		@@ -57,6 +58,7 @@ void slideshow(void);
57	58		void clear_resize(void);
58	59
59	60		appmode_t mode;
	61	+	arl_t arl;
60	62		img_t img;
61	63		tns_t tns;
62	64		win_t win;
		@@ -65,7 +67,6 @@ fileinfo_t *files;
65	67		int filecnt, fileidx;
66	68		int alternate;
67	69		int markcnt;
68		−	autoreload_t autoreload;
69	70
70	71		int prefix;
71	72		bool extprefix;
		@@ -100,7 +101,7 @@ timeout_t timeouts[] = {
100	101		void cleanup(void)
101	102		{
102	103		img_close(&img, false);
103		−	arl_cleanup();
	104	+	arl_cleanup(&arl);
104	105		tns_free(&tns);
105	106		win_close(&win);
106	107		}
		@@ -320,7 +321,7 @@ void load_image(int new)
320	321
321	322		info.open = false;
322	323		open_info();
323		−	arl_setup();
	324	+	arl_setup(&arl, files[fileidx].path);
324	325
325	326		if (img.multi.cnt > 0 && img.multi.animate)
326	327		set_timeout(animate, img.multi.frames[img.multi.sel].delay, true);
		@@ -676,6 +677,8 @@ void on_buttonpress(XButtonEvent *bev)
676	677		prefix = 0;
677	678		}
678	679
	680	+	const struct timespec ten_ms = {0, 10000000};
	681	+
679	682		void run(void)
680	683		{
681	684		int xfd;
		@@ -689,8 +692,8 @@ void run(void)
689	692		init_thumb = mode == MODE_THUMB && tns.initnext < filecnt;
690	693		load_thumb = mode == MODE_THUMB && tns.loadnext < tns.end;
691	694
692		−	if ((init_thumb \|\| load_thumb \|\| to_set \|\| info.fd != -1 \|\| autoreload.fd != -1) &&
693		−	XPending(win.env.dpy) == 0)
	695	+	if ((init_thumb \|\| load_thumb \|\| to_set \|\| info.fd != -1 \|\|
	696	+	arl.fd != -1) && XPending(win.env.dpy) == 0)
694	697		{
695	698		if (load_thumb) {
696	699		set_timeout(redraw, TO_REDRAW_THUMBS, false);
		@@ -712,15 +715,21 @@ void run(void)
712	715		FD_SET(info.fd, &fds);
713	716		xfd = MAX(xfd, info.fd);
714	717		}
715		−	if (autoreload.fd != -1) {
716		−	FD_SET(autoreload.fd, &fds);
717		−	xfd = MAX(xfd, autoreload.fd);
	718	+	if (arl.fd != -1) {
	719	+	FD_SET(arl.fd, &fds);
	720	+	xfd = MAX(xfd, arl.fd);
718	721		}
719	722		select(xfd + 1, &fds, 0, 0, to_set ? &timeout : NULL);
720	723		if (info.fd != -1 && FD_ISSET(info.fd, &fds))
721	724		read_info();
722		−	if (autoreload.fd != -1 && FD_ISSET(autoreload.fd, &fds))
723		−	arl_handle();
	725	+	if (arl.fd != -1 && FD_ISSET(arl.fd, &fds)) {
	726	+	if (arl_handle(&arl, files[fileidx].path)) {
	727	+	/* when too fast, imlib2 can't load the image */
	728	+	nanosleep(&ten_ms, NULL);
	729	+	load_image(fileidx);
	730	+	redraw();
	731	+	}
	732	+	}
724	733		}
725	734		continue;
726	735		}
		@@ -864,7 +873,7 @@ int main(int argc, char **argv)
864	873
865	874		win_init(&win);
866	875		img_init(&img, &win);
867		−	arl_init();
	876	+	arl_init(&arl);
868	877
869	878		if ((homedir = getenv("XDG_CONFIG_HOME")) == NULL \|\| homedir[0] == '\0') {
870	879		homedir = getenv("HOME");

nsxiv/3724d3f

Revised autoreload interface

nsxiv3724d3f