rebase off of Luke's dwmblocks

4 files changed, 101 insertions, 42 deletions

diff --git a/Makefile b/Makefile
index 0349015..5cfbb5a 100644
--- a/Makefile
+++ b/Makefile
@@ -4,9 +4,9 @@ PREFIX = /usr/local
 CC = gcc
 
 dwmblocks: dwmblocks.o
-	$(CC) dwmblocks.o -lX11 -o dwmblocks -L/usr/X11R6/lib
+	$(CC) dwmblocks.o -lX11 -o dwmblocks
 dwmblocks.o: dwmblocks.c config.h
-	$(CC) -std=c99 -c dwmblocks.c -I/usr/X11R6/include
+	$(CC) -c dwmblocks.c
 clean:
 	rm -f *.o *.gch dwmblocks
 install: dwmblocks
diff --git a/README.md b/README.md
index b6a4685..aa0ee05 100644
--- a/README.md
+++ b/README.md
@@ -2,18 +2,22 @@
 
 Modular status bar for dwm written in c.
 
+# ZachIR's fork of Luke Smith's config of dwmblocks
+
+Hence, most of what you see below will be very familiar if you read Luke's
+README.
+
 # Modifying blocks
 
 The statusbar is made from text output from commandline programs.  Blocks are
 added and removed by editing the config.h file.
 
-# Luke's build
+# ZachIR's build
 
 I have dwmblocks read my preexisting scripts
-[here in my dotfiles repo](https://github.com/LukeSmithxyz/voidrice/tree/master/.local/bin/statusbar).
+[here in my scripts repo](https://gitlab.com/zachir/scripts).
 So if you want my build out of the box, download those and put them in your
-`$PATH`. I do this to avoid redundancy in LARBS, both i3 and dwm use the same
-statusbar scripts.
+`$PATH`.
 
 # Signaling changes
 
@@ -22,7 +26,7 @@ This is an option here, but a superior choice is giving your module a signal
 that you can signal to it to update on a relevant event, rather than having it
 rerun idly.
 
-For example, the audio module has the update signal 10 by default.  Thus,
+For example, the volume module has the update signal 10 by default.  Thus,
 running `pkill -RTMIN+10 dwmblocks` will update it.
 
 You can also run `kill -44 $(pidof dwmblocks)` which will have the same effect,
@@ -31,9 +35,7 @@ but is faster.  Just add 34 to your typical signal number.
 My volume module *never* updates on its own, instead I have this command run
 along side my volume shortcuts in dwm to only update it when relevant.
 
-Note that if you signal an unexpected signal to dwmblocks, it will probably
-crash. So if you disable a module, remember to also disable any cronjobs or
-other scripts that might signal to that module.
+Note that all modules must have different signal numbers.
 
 # Clickable modules
 
diff --git a/config.h b/config.h
index 2f7c63c..f26803e 100644
--- a/config.h
+++ b/config.h
@@ -1,11 +1,11 @@
 //Modify this file to change what commands output to your statusbar, and recompile using the make command.
 static const Block blocks[] = {
 	/*Icon*/	/*Command*/		/*Update Interval*/	/*Update Signal*/
-	/* {"", "cat /tmp/recordingicon 2>/dev/null",	0,	9}, */
+	{"", "cat /tmp/recordingicon 2>/dev/null",	0,	9},
         {"",    "mailbox",      900,    23},
 	{"",	"music",	10,	11},
-	/* {"",	"pacpackages",	10,	8}, */
-	/* {"",    "xidlechk",     0,      19}, */
+	{"",	"pacpackages",	10,	8},
+	{"",    "xidlechk",     0,      19},
 	/* {"",	"news",		0,	6}, */
 	/* {"",	"crypto",	0,	13}, */
 	/* {"",	"price bat \"Basic Attention Token\" 🦁",	0,	20}, */
diff --git a/dwmblocks.c b/dwmblocks.c
index 68267d7..0969ed7 100644
--- a/dwmblocks.c
+++ b/dwmblocks.c
@@ -1,10 +1,12 @@
-#include<stdlib.h>
-#include<stdio.h>
-#include<string.h>
-#include<unistd.h>
-#include<signal.h>
-#include<X11/Xlib.h>
-#define LENGTH(X)               (sizeof(X) / sizeof (X[0]))
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <signal.h>
+#include <errno.h>
+#include <X11/Xlib.h>
+#define LENGTH(X) (sizeof(X) / sizeof (X[0]))
 #define CMDLENGTH		50
 
 typedef struct {
@@ -41,25 +43,38 @@ static void (*writestatus) () = setroot;
 
 void replace(char *str, char old, char new)
 {
-	int N = strlen(str);
-	for(int i = 0; i < N; i++)
-		if(str[i] == old)
-			str[i] = new;
+	for(char * c = str; *c; c++)
+		if(*c == old)
+			*c = new;
 }
 
+// the previous function looked nice but unfortunately it didnt work if to_remove was in any position other than the last character
+// theres probably still a better way of doing this
 void remove_all(char *str, char to_remove) {
 	char *read = str;
 	char *write = str;
 	while (*read) {
-		if (*read == to_remove) {
-			read++;
-			*write = *read;
+		if (*read != to_remove) {
+			*write++ = *read;
 		}
-		read++;
-		write++;
+		++read;
 	}
+	*write = '\0';
 }
 
+int gcd(int a, int b)
+{
+	int temp;
+	while (b > 0){
+		temp = a % b;
+
+		a = b;
+		b = temp;
+	}
+	return a;
+}
+
+
 //opens process *cmd and stores output in *output
 void getcmd(const Block *block, char *output)
 {
@@ -68,21 +83,37 @@ void getcmd(const Block *block, char *output)
 		output[0] = block->signal;
 		output++;
 	}
-	strcpy(output, block->icon);
 	char *cmd = block->command;
 	FILE *cmdf = popen(cmd,"r");
-	if (!cmdf)
+	if (!cmdf){
+        //printf("failed to run: %s, %d\n", block->command, errno);
 		return;
-	char c;
+    }
+    char tmpstr[CMDLENGTH] = "";
+    // TODO decide whether its better to use the last value till next time or just keep trying while the error was the interrupt
+    // this keeps trying to read if it got nothing and the error was an interrupt
+    //  could also just read to a separate buffer and not move the data over if interrupted
+    //  this way will take longer trying to complete 1 thing but will get it done
+    //  the other way will move on to keep going with everything and the part that failed to read will be wrong till its updated again
+    // either way you have to save the data to a temp buffer because when it fails it writes nothing and then then it gets displayed before this finishes
+	char * s;
+    int e;
+    do {
+        errno = 0;
+        s = fgets(tmpstr, CMDLENGTH-(strlen(delim)+1), cmdf);
+        e = errno;
+    } while (!s && e == EINTR);
+	pclose(cmdf);
 	int i = strlen(block->icon);
-	fgets(output+i, CMDLENGTH-(strlen(delim)+1), cmdf);
+	strcpy(output, block->icon);
+    strcpy(output+i, tmpstr);
 	remove_all(output, '\n');
 	i = strlen(output);
-    if ((i > 0 && block != &blocks[LENGTH(blocks) - 1]))
+    if ((i > 0 && block != &blocks[LENGTH(blocks) - 1])){
         strcat(output, delim);
+    }
     i+=strlen(delim);
 	output[i++] = '\0';
-	pclose(cmdf);
 }
 
 void getcmds(int time)
@@ -91,8 +122,9 @@ void getcmds(int time)
 	for(int i = 0; i < LENGTH(blocks); i++)
 	{
 		current = blocks + i;
-		if ((current->interval != 0 && time % current->interval == 0) || time == -1)
+		if ((current->interval != 0 && time % current->interval == 0) || time == -1){
 			getcmd(current,statusbar[i]);
+        }
 	}
 }
 
@@ -103,14 +135,19 @@ void getsigcmds(int signal)
 	for (int i = 0; i < LENGTH(blocks); i++)
 	{
 		current = blocks + i;
-		if (current->signal == signal)
+		if (current->signal == signal){
 			getcmd(current,statusbar[i]);
+        }
 	}
 }
 
 void setupsignals()
 {
 	struct sigaction sa;
+
+	for(int i = SIGRTMIN; i <= SIGRTMAX; i++)
+		signal(i, SIG_IGN);
+
 	for(int i = 0; i < LENGTH(blocks); i++)
 	{
 		if (blocks[i].signal > 0)
@@ -172,14 +209,34 @@ void statusloop()
 #ifndef __OpenBSD__
 	setupsignals();
 #endif
-	int i = 0;
+    // first figure out the default wait interval by finding the
+    // greatest common denominator of the intervals
+    unsigned int interval = -1;
+    for(int i = 0; i < LENGTH(blocks); i++){
+        if(blocks[i].interval){
+            interval = gcd(blocks[i].interval, interval);
+        }
+    }
+	unsigned int i = 0;
+    int interrupted = 0;
+    const struct timespec sleeptime = {interval, 0};
+    struct timespec tosleep = sleeptime;
 	getcmds(-1);
 	while(statusContinue)
 	{
-		getcmds(i);
-		writestatus();
-		sleep(1.0);
-		i++;
+        // sleep for tosleep (should be a sleeptime of interval seconds) and put what was left if interrupted back into tosleep
+        interrupted = nanosleep(&tosleep, &tosleep);
+        // if interrupted then just go sleep again for the remaining time
+        if(interrupted == -1){
+            continue;
+        }
+        // if not interrupted then do the calling and writing
+        getcmds(i);
+        writestatus();
+        // then increment since its actually been a second (plus the time it took the commands to run)
+        i += interval;
+        // set the time to sleep back to the sleeptime of 1s
+        tosleep = sleeptime;
 	}
 }