Llewellyn/conky
1
0
Fork 0
mirror of https://github.com/Llewellynvdm/conky.git synced 2025-01-26 16:48:28 +00:00
Code Issues Releases Activity

Merge branch 'master' of git://nwl.cc/~n0-1/conky

Browse Source
This commit is contained in:
Brenden Matthews 2008-12-15 21:01:58 -07:00
commit 621bad14f8
3 changed files with 99 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

230
src/conky.c
View File

@ -118,7 +118,11 @@ static char *tmpstring1, *tmpstring2;
/* variables holding various config settings */
int short_units;
int cpu_separate;
static int use_spacer;
enum {
NO_SPACER = 0,
LEFT_SPACER,
RIGHT_SPACER
} use_spacer;
int top_cpu, top_mem;
#define TO_X 1
#define TO_STDOUT 2
@ -1068,11 +1072,10 @@ static void convert_escapes(char *buf)
/* Prints anything normally printed with snprintf according to the current value
* of use_spacer. Actually slightly more flexible than snprintf, as you can
* safely specify the destination buffer as one of your inputs. */
static int spaced_print(char *, int, const char *, int, const char *, ...)
__attribute__((format(printf, 3, 6)));
static int spaced_print(char *, int, const char *, int, ...)
__attribute__((format(printf, 3, 5)));
static int spaced_print(char *buf, int size, const char *format, int width,
const char *func_name, ...) {
static int spaced_print(char *buf, int size, const char *format, int width, ...) {
int len;
va_list argp;
char *tempbuf;
@ -1083,7 +1086,7 @@ static int spaced_print(char *buf, int size, const char *format, int width,
tempbuf = malloc(size * sizeof(char));
// Passes the varargs along to vsnprintf
va_start(argp, func_name);
va_start(argp, width);
vsnprintf(tempbuf, size, format, argp);
va_end(argp);
@ -1097,35 +1100,37 @@ static int spaced_print(char *buf, int size, const char *format, int width,
case RIGHT_SPACER:
len = snprintf(buf, size, "%-*s", width - 1, tempbuf);
break;
default:
CRIT_ERR("%s encountered invalid use_spacer value (%d)", func_name,
use_spacer);
}
free(tempbuf);
return len;
}
/* converts from bytes to human readable format (k, M, G, T) */
static void human_readable(long long num, char *buf, int size, const char *func_name)
static void human_readable(long long num, char *buf, int size)
{
const char **suffix = suffixes;
float fnum;
int precision, len;
static const int WIDTH = 10, SHORT_WIDTH = 8;
int width;
const char *format, *format2;
if (num < 1024LL && num > -1024LL) {
if (short_units) {
spaced_print(buf, size, "%lld%c", SHORT_WIDTH, func_name, num,
**suffix);
} else {
spaced_print(buf, size, "%lld%s", WIDTH, func_name, num, *suffix);
}
if (short_units) {
width = SHORT_WIDTH;
format = "%lld%1s";
format2 = "%.*f%1s";
} else {
width = WIDTH;
format = "%lld%s";
format2 = "%.*f%s";
}
if (llabs(num) < 1024LL) {
spaced_print(buf, size, format, width, num, *suffix);
return;
}
while ((num / 1024 >= 1000LL || num / 1024 <= -1024LL) && **(suffix + 2)) {
while (llabs(num / 1024) >= 1024LL && **(suffix + 2)) {
num /= 1024;
suffix++;
}
@ -1139,14 +1144,9 @@ static void human_readable(long long num, char *buf, int size, const char *func_
if (precision < 0) {
break;
}
if (short_units) {
len = spaced_print(buf, size, "%.*f%c", SHORT_WIDTH, func_name,
precision, fnum, **suffix);
} else {
len = spaced_print(buf, size, "%.*f%s", WIDTH, func_name, precision,
fnum, *suffix);
}
} while (len >= (short_units ? SHORT_WIDTH : WIDTH) || len >= size);
len = spaced_print(buf, size, format2, width,
precision, fnum, *suffix);
} while (len >= MAX(width, size));
}
/* global object list root element */
@ -1557,11 +1557,14 @@ void scan_mixer_bar(const char *arg, int *a, int *w, int *h)
* which gets overwritten in consecutive calls. I.e.:
* this function is NOT reentrant.
*/
const char *dev_name(const char *path)
static const char *dev_name(const char *path)
{
static char buf[255]; /* should be enough for pathnames */
ssize_t buflen;
if (!path)
return NULL;
#define DEV_NAME(x) \
x != NULL && strlen(x) > 5 && strncmp(x, "/dev/", 5) == 0 ? x + 5 : x
if ((buflen = readlink(path, buf, 254)) == -1)
@ -1889,53 +1892,32 @@ static struct text_object *construct_text_object(const char *s,
}
#if defined(__linux__)
END OBJ(diskio, INFO_DISKIO)
if (arg) {
obj->data.diskio = prepare_diskio_stat(dev_name(arg));
} else {
obj->data.diskio = NULL;
}
obj->data.diskio = prepare_diskio_stat(dev_name(arg));
END OBJ(diskio_read, INFO_DISKIO)
if (arg) {
obj->data.diskio = prepare_diskio_stat(dev_name(arg));
} else {
obj->data.diskio = NULL;
}
obj->data.diskio = prepare_diskio_stat(dev_name(arg));
END OBJ(diskio_write, INFO_DISKIO)
if (arg) {
obj->data.diskio = prepare_diskio_stat(dev_name(arg));
} else {
obj->data.diskio = NULL;
}
obj->data.diskio = prepare_diskio_stat(dev_name(arg));
END OBJ(diskiograph, INFO_DISKIO)
char *buf = scan_graph(dev_name(arg), &obj->a, &obj->b, &obj->c, &obj->d,
&obj->e, &obj->showaslog);
if (buf) {
obj->data.diskio = prepare_diskio_stat(buf);
obj->data.diskio = prepare_diskio_stat(buf);
if (buf)
free(buf);
} else {
obj->data.diskio = NULL;
}
END OBJ(diskiograph_read, INFO_DISKIO)
char *buf = scan_graph(dev_name(arg), &obj->a, &obj->b, &obj->c, &obj->d,
&obj->e, &obj->showaslog);
if (buf) {
obj->data.diskio = prepare_diskio_stat(buf);
obj->data.diskio = prepare_diskio_stat(buf);
if (buf)
free(buf);
} else {
obj->data.diskio = NULL;
}
END OBJ(diskiograph_write, INFO_DISKIO)
char *buf = scan_graph(dev_name(arg), &obj->a, &obj->b, &obj->c, &obj->d,
&obj->e, &obj->showaslog);
if (buf) {
obj->data.diskio = prepare_diskio_stat(buf);
obj->data.diskio = prepare_diskio_stat(buf);
if (buf)
free(buf);
} else {
obj->data.diskio = NULL;
}
#endif
END OBJ(color, 0)
#ifdef X11
@ -3832,22 +3814,20 @@ static void generate_text_internal(char *p, int p_max_size,
snprintf(p, p_max_size, "%s", obj->data.net->ap);
}
OBJ(wireless_link_qual) {
spaced_print(p, p_max_size, "%d", 4, "wireless_link_qual",
spaced_print(p, p_max_size, "%d", 4,
obj->data.net->link_qual);
}
OBJ(wireless_link_qual_max) {
spaced_print(p, p_max_size, "%d", 4,
"wireless_link_qual_max", obj->data.net->link_qual_max);
obj->data.net->link_qual_max);
}
OBJ(wireless_link_qual_perc) {
if (obj->data.net->link_qual_max > 0) {
spaced_print(p, p_max_size, "%.0f", 5,
"wireless_link_qual_perc",
(double) obj->data.net->link_qual /
obj->data.net->link_qual_max * 100);
} else {
spaced_print(p, p_max_size, "unk", 5,
"wireless_link_qual_perc");
spaced_print(p, p_max_size, "unk", 5);
}
}
OBJ(wireless_link_bar) {
@ -3878,7 +3858,7 @@ static void generate_text_internal(char *p, int p_max_size,
get_battery_stuff(p, p_max_size, obj->data.s, BATTERY_TIME);
}
OBJ(battery_percent) {
spaced_print(p, p_max_size, "%*d", 4, "battery_percent",
spaced_print(p, p_max_size, "%*d", 4,
pad_percents, get_battery_perct(obj->data.s));
}
OBJ(battery_bar) {
@ -3887,10 +3867,10 @@ static void generate_text_internal(char *p, int p_max_size,
#endif /* __OpenBSD__ */
OBJ(buffers) {
human_readable(cur->buffers * 1024, p, 255, "buffers");
human_readable(cur->buffers * 1024, p, 255);
}
OBJ(cached) {
human_readable(cur->cached * 1024, p, 255, "buffers");
human_readable(cur->cached * 1024, p, 255);
}
OBJ(cpu) {
if (obj->data.cpu_index > info.cpu_count) {
@ -3898,7 +3878,7 @@ static void generate_text_internal(char *p, int p_max_size,
obj->data.cpu_index, info.cpu_count);
CRIT_ERR("attempting to use more CPUs than you have!");
}
spaced_print(p, p_max_size, "%*d", 4, "cpu", pad_percents,
spaced_print(p, p_max_size, "%*d", 4, pad_percents,
round_to_int(cur->cpu_usage[obj->data.cpu_index] * 100.0));
}
OBJ(cpubar) {
@ -4102,66 +4082,35 @@ static void generate_text_internal(char *p, int p_max_size,
/* TODO: move this correction from kB to kB/s elsewhere
* (or get rid of it??) */
OBJ(diskio) {
if (obj->data.diskio) {
human_readable(
(obj->data.diskio->current / update_interval) * 1024LL,
p, p_max_size, "diskio");
} else {
human_readable(info.diskio_value * 1024LL, p, p_max_size,
"diskio");
}
human_readable((obj->data.diskio->current / update_interval) * 1024LL,
p, p_max_size);
}
OBJ(diskio_write) {
if (obj->data.diskio) {
human_readable((obj->data.diskio->current_write / update_interval) * 1024LL, p, p_max_size,
"diskio_write");
} else {
human_readable(info.diskio_write_value * 1024LL, p, p_max_size,
"diskio_write");
}
human_readable((obj->data.diskio->current / update_interval) * 1024LL,
p, p_max_size);
}
OBJ(diskio_read) {
if (obj->data.diskio) {
human_readable((obj->data.diskio->current_read / update_interval) * 1024LL, p, p_max_size,
"diskio_read");
} else {
human_readable(info.diskio_read_value * 1024LL, p, p_max_size,
"diskio_read");
}
human_readable((obj->data.diskio->current / update_interval) * 1024LL,
p, p_max_size);
}
OBJ(diskiograph) {
if (obj->data.diskio) {
new_graph(p, obj->a, obj->b, obj->c, obj->d,
obj->data.diskio->current, obj->e, 1, obj->showaslog);
} else {
new_graph(p, obj->a, obj->b, obj->c, obj->d, info.diskio_value,
obj->e, 1, obj->showaslog);
}
new_graph(p, obj->a, obj->b, obj->c, obj->d,
obj->data.diskio->current, obj->e, 1, obj->showaslog);
}
OBJ(diskiograph_read) {
if (obj->data.diskio) {
new_graph(p, obj->a, obj->b, obj->c, obj->d,
obj->data.diskio->current_read, obj->e, 1, obj->showaslog);
} else {
new_graph(p, obj->a, obj->b, obj->c, obj->d,
info.diskio_read_value, obj->e, 1, obj->showaslog);
}
new_graph(p, obj->a, obj->b, obj->c, obj->d,
obj->data.diskio->current_read, obj->e, 1, obj->showaslog);
}
OBJ(diskiograph_write) {
if (obj->data.diskio) {
new_graph(p, obj->a, obj->b, obj->c, obj->d,
obj->data.diskio->current_write, obj->e, 1, obj->showaslog);
} else {
new_graph(p, obj->a, obj->b, obj->c, obj->d,
info.diskio_write_value, obj->e, 1, obj->showaslog);
}
new_graph(p, obj->a, obj->b, obj->c, obj->d,
obj->data.diskio->current_write, obj->e, 1, obj->showaslog);
}
OBJ(downspeed) {
spaced_print(p, p_max_size, "%d", 6, "downspeed",
spaced_print(p, p_max_size, "%d", 6,
round_to_int(obj->data.net->recv_speed / 1024));
}
OBJ(downspeedf) {
spaced_print(p, p_max_size, "%.1f", 8, "downspeedf",
spaced_print(p, p_max_size, "%.1f", 8,
obj->data.net->recv_speed / 1024.0);
}
OBJ(downspeedgraph) {
@ -4424,13 +4373,13 @@ static void generate_text_internal(char *p, int p_max_size,
}
OBJ(fs_free) {
if (obj->data.fs != NULL) {
human_readable(obj->data.fs->avail, p, 255, "fs_free");
human_readable(obj->data.fs->avail, p, 255);
}
}
OBJ(fs_free_perc) {
if (obj->data.fs != NULL) {
if (obj->data.fs->size) {
spaced_print(p, p_max_size, "%*d", 4, "fs_free_perc",
spaced_print(p, p_max_size, "%*d", 4,
pad_percents, (int) ((obj->data.fs->avail * 100) /
obj->data.fs->size));
} else {
@ -4440,7 +4389,7 @@ static void generate_text_internal(char *p, int p_max_size,
}
OBJ(fs_size) {
if (obj->data.fs != NULL) {
human_readable(obj->data.fs->size, p, 255, "fs_size");
human_readable(obj->data.fs->size, p, 255);
}
}
OBJ(fs_type) {
@ -4450,8 +4399,7 @@ static void generate_text_internal(char *p, int p_max_size,
OBJ(fs_used) {
if (obj->data.fs != NULL) {
human_readable(obj->data.fs->size - (obj->data.fs->free
? obj->data.fs->free : obj->data.fs->avail), p, 255,
"fs_used");
? obj->data.fs->free : obj->data.fs->avail), p, 255);
}
}
OBJ(fs_bar_free) {
@ -4468,7 +4416,7 @@ static void generate_text_internal(char *p, int p_max_size,
OBJ(fs_used_perc) {
if (obj->data.fs != NULL) {
if (obj->data.fs->size) {
spaced_print(p, 4, "%*d", 4, "fs_used_perc",
spaced_print(p, 4, "%*d", 4,
pad_percents, 100 - ((int) ((obj->data.fs->avail * 100) /
obj->data.fs->size)));
} else {
@ -4715,20 +4663,20 @@ static void generate_text_internal(char *p, int p_max_size,
/* memory stuff */
OBJ(mem) {
human_readable(cur->mem * 1024, p, 255, "mem");
human_readable(cur->mem * 1024, p, 255);
}
OBJ(memeasyfree) {
human_readable(cur->memeasyfree * 1024, p, 255, "memeasyfree");
human_readable(cur->memeasyfree * 1024, p, 255);
}
OBJ(memfree) {
human_readable(cur->memfree * 1024, p, 255, "memfree");
human_readable(cur->memfree * 1024, p, 255);
}
OBJ(memmax) {
human_readable(cur->memmax * 1024, p, 255, "memmax");
human_readable(cur->memmax * 1024, p, 255);
}
OBJ(memperc) {
if (cur->memmax) {
spaced_print(p, p_max_size, "%*llu", 4, "memperc",
spaced_print(p, p_max_size, "%*llu", 4,
pad_percents, cur->mem * 100 / cur->memmax);
}
}
@ -4795,10 +4743,10 @@ static void generate_text_internal(char *p, int p_max_size,
new_outline(p, obj->data.l);
}
OBJ(processes) {
spaced_print(p, p_max_size, "%hu", 5, "processes", cur->procs);
spaced_print(p, p_max_size, "%hu", 5, cur->procs);
}
OBJ(running_processes) {
spaced_print(p, p_max_size, "%hu", 3, "running_processes", cur->run_procs);
spaced_print(p, p_max_size, "%hu", 3, cur->run_procs);
}
OBJ(text) {
snprintf(p, p_max_size, "%s", obj->data.s);
@ -4810,16 +4758,16 @@ static void generate_text_internal(char *p, int p_max_size,
new_stippled_hr(p, obj->data.pair.a, obj->data.pair.b);
}
OBJ(swap) {
human_readable(cur->swap * 1024, p, 255, "swap");
human_readable(cur->swap * 1024, p, 255);
}
OBJ(swapmax) {
human_readable(cur->swapmax * 1024, p, 255, "swapmax");
human_readable(cur->swapmax * 1024, p, 255);
}
OBJ(swapperc) {
if (cur->swapmax == 0) {
strncpy(p, "No swap", p_max_size);
} else {
spaced_print(p, p_max_size, "%*llu", 4, "swapperc",
spaced_print(p, p_max_size, "%*llu", 4,
pad_percents, cur->swap * 100 / cur->swapmax);
}
}
@ -4867,20 +4815,20 @@ static void generate_text_internal(char *p, int p_max_size,
// Needless to free oldTZ since getenv gives ptr to static data
}
OBJ(totaldown) {
human_readable(obj->data.net->recv, p, 255, "totaldown");
human_readable(obj->data.net->recv, p, 255);
}
OBJ(totalup) {
human_readable(obj->data.net->trans, p, 255, "totalup");
human_readable(obj->data.net->trans, p, 255);
}
OBJ(updates) {
snprintf(p, p_max_size, "%d", total_updates);
}
OBJ(upspeed) {
spaced_print(p, p_max_size, "%d", 6, "upspeed",
spaced_print(p, p_max_size, "%d", 6,
round_to_int(obj->data.net->trans_speed / 1024));
}
OBJ(upspeedf) {
spaced_print(p, p_max_size, "%.1f", 8, "upspeedf",
spaced_print(p, p_max_size, "%.1f", 8,
obj->data.net->trans_speed / 1024.0);
}
OBJ(upspeedgraph) {
@ -4989,7 +4937,7 @@ static void generate_text_internal(char *p, int p_max_size,
format_media_player_time(p, p_max_size, cur->mpd.length);
}
OBJ(mpd_percent) {
spaced_print(p, p_max_size, "%*d", 4, "mpd_percent",
spaced_print(p, p_max_size, "%*d", 4,
pad_percents, (int) (cur->mpd.progress * 100));
}
OBJ(mpd_bar) {
@ -5247,11 +5195,11 @@ static void generate_text_internal(char *p, int p_max_size,
break;
case TOP_MEM_RES:
human_readable(cur->cpu[obj->data.top.num]->rss,
p, 255, "top_rss");
p, 255);
break;
case TOP_MEM_VSIZE:
human_readable(cur->cpu[obj->data.top.num]->vsize,
p, 255, "top_rss");
p, 255);
break;
default:
ERR("Unhandled top data type: %d\n",
@ -5291,11 +5239,11 @@ static void generate_text_internal(char *p, int p_max_size,
break;
case TOP_MEM_RES:
human_readable(cur->cpu[obj->data.top.num]->rss,
p, 255, "top_rss");
p, 255);
break;
case TOP_MEM_VSIZE:
human_readable(cur->cpu[obj->data.top.num]->vsize,
p, 255, "top_rss");
p, 255);
break;
default:
ERR("Unhandled top data type: %d\n",
@ -5539,7 +5487,7 @@ head:
if(obj->data.s && sscanf(obj->data.s, "%i", &idx) == 1) {
val = smapi_bat_installed(idx) ?
smapi_get_bat_int(idx, "remaining_percent") : 0;
spaced_print(p, p_max_size, "%*d", 4, "smapi_bat_perc", pad_percents, val);
spaced_print(p, p_max_size, "%*d", 4, pad_percents, val);
} else
ERR("argument to smapi_bat_perc must be an integer");
}
@ -5677,10 +5625,6 @@ static void generate_text(void)
current_update_time = get_time();
update_stuff();
/* fix diskio rates to b/s (use update_interval */
info.diskio_read_value /= update_interval;
info.diskio_write_value /= update_interval;
info.diskio_value /= update_interval;
/* add things to the buffer */

6
src/conky.h
View File

@ -266,10 +266,6 @@ struct information {
#endif
short kflags; /* kernel settings, see enum KFLAG */
unsigned int diskio_value;
unsigned int diskio_read_value;
unsigned int diskio_write_value;
};
/* needed by linux.c and top.c -> outsource somewhere */
@ -290,8 +286,6 @@ enum {
/* defined in conky.c, needed by top.c */
extern int top_cpu, top_mem;
enum spacer_opts { NO_SPACER = 0, LEFT_SPACER, RIGHT_SPACER };
/* defined in conky.c, needed by top.c */
extern int cpu_separate;

19
src/diskio.c
View File

@ -54,7 +54,7 @@ struct diskio_stat *diskio_stats = diskio_stats_;
void clear_diskio_stats(void)
{
unsigned i;
for(i = 0; i < MAX_DISKIO_STATS; i++) {
for(i = 1; i < MAX_DISKIO_STATS; i++) {
if (diskio_stats[i].dev) {
free(diskio_stats[i].dev);
diskio_stats[i].dev = 0;
@ -70,8 +70,12 @@ struct diskio_stat *prepare_diskio_stat(const char *s)
int found = 0;
char device[text_buffer_size], fbuf[text_buffer_size];
static int rep = 0;
if (!s)
return &diskio_stats[0];
/* lookup existing or get new */
for (i = 0; i < MAX_DISKIO_STATS; i++) {
for (i = 1; i < MAX_DISKIO_STATS; i++) {
if (diskio_stats[i].dev) {
if (strcmp(diskio_stats[i].dev, s) == 0) {
return &diskio_stats[i];
@ -145,7 +149,8 @@ void update_diskio(void)
int tot, tot_read, tot_write;
if (!(fp = open_file("/proc/diskstats", &rep))) {
info.diskio_value = 0;
diskio_stats[0].current = 0;
return;
}
@ -171,7 +176,7 @@ void update_diskio(void)
continue;
}
}
for (i = 0; i < MAX_DISKIO_STATS; i++) {
for (i = 1; i < MAX_DISKIO_STATS; i++) {
if (diskio_stats[i].dev &&
strncmp(devbuf, diskio_stats[i].dev, text_buffer_size) == 0) {
diskio_stats[i].current =
@ -222,9 +227,9 @@ void update_diskio(void)
last_read = current_read;
last_write = current_write;
info.diskio_value = tot;
info.diskio_read_value = tot_read;
info.diskio_write_value = tot_write;
diskio_stats[0].current = tot;
diskio_stats[0].current_read = tot_read;
diskio_stats[0].current_write = tot_write;
fclose(fp);
}