mirror of
https://github.com/Llewellynvdm/conky.git
synced 2025-02-05 13:38:33 +00:00
huge bunch of trivial conversions to obj->callbacks
This commit is contained in:
Phil Sutter
parent
7b05bdd665
commit
fa3118993e
411
src/conky.c
411
src/conky.c
@ -78,9 +78,7 @@
|
||||
#include "colours.h"
|
||||
#include "combine.h"
|
||||
#include "diskio.h"
|
||||
#include "entropy.h"
|
||||
#include "exec.h"
|
||||
#include "i8k.h"
|
||||
#include "proc.h"
|
||||
#include "user.h"
|
||||
#ifdef X11
|
||||
@ -821,9 +819,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
switch (obj->type) {
|
||||
default:
|
||||
NORM_ERR("not implemented obj type %d", obj->type);
|
||||
OBJ(read_tcp) {
|
||||
print_read_tcp(obj, p, p_max_size);
|
||||
}
|
||||
#ifndef __OpenBSD__
|
||||
OBJ(acpitemp) {
|
||||
temp_print(p, p_max_size, get_acpi_temperature(obj->data.i), TEMP_CELSIUS);
|
||||
@ -849,43 +844,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
#endif /* __OpenBSD */
|
||||
}
|
||||
}
|
||||
#if defined(__linux__)
|
||||
OBJ(voltage_mv) {
|
||||
print_voltage_mv(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(voltage_v) {
|
||||
print_voltage_v(obj, p, p_max_size);
|
||||
}
|
||||
|
||||
#ifdef HAVE_IWLIB
|
||||
OBJ(wireless_essid) {
|
||||
print_wireless_essid(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(wireless_mode) {
|
||||
print_wireless_mode(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(wireless_bitrate) {
|
||||
print_wireless_bitrate(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(wireless_ap) {
|
||||
print_wireless_ap(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(wireless_link_qual) {
|
||||
print_wireless_link_qual(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(wireless_link_qual_max) {
|
||||
print_wireless_link_qual_max(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(wireless_link_qual_perc) {
|
||||
print_wireless_link_qual_perc(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(wireless_link_bar) {
|
||||
print_wireless_link_bar(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* HAVE_IWLIB */
|
||||
|
||||
#endif /* __linux__ */
|
||||
|
||||
#ifndef __OpenBSD__
|
||||
OBJ(acpifan) {
|
||||
get_acpi_fan(p, p_max_size);
|
||||
@ -981,50 +939,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
snprintf(p, p_max_size, "%s",
|
||||
get_disk_protect_queue(obj->data.s));
|
||||
}
|
||||
OBJ(i8k_version) {
|
||||
print_i8k_version(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(i8k_bios) {
|
||||
print_i8k_bios(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(i8k_serial) {
|
||||
print_i8k_serial(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(i8k_cpu_temp) {
|
||||
print_i8k_cpu_temp(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(i8k_left_fan_status) {
|
||||
print_i8k_left_fan_status(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(i8k_right_fan_status) {
|
||||
print_i8k_right_fan_status(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(i8k_left_fan_rpm) {
|
||||
print_i8k_left_fan_rpm(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(i8k_right_fan_rpm) {
|
||||
print_i8k_right_fan_rpm(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(i8k_ac_status) {
|
||||
print_i8k_ac_status(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(i8k_buttons_status) {
|
||||
print_i8k_buttons_status(obj, p, p_max_size);
|
||||
}
|
||||
#if defined(IBM)
|
||||
OBJ(ibm_fan) {
|
||||
get_ibm_acpi_fan(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(ibm_temps) {
|
||||
print_ibm_temps(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(ibm_volume) {
|
||||
get_ibm_acpi_volume(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(ibm_brightness) {
|
||||
get_ibm_acpi_brightness(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* IBM */
|
||||
/* information from sony_laptop kernel module
|
||||
* /sys/devices/platform/sony-laptop */
|
||||
OBJ(sony_fanspeed) {
|
||||
@ -1056,15 +970,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
}
|
||||
#endif
|
||||
#ifdef __OpenBSD__
|
||||
OBJ(obsd_sensors_temp) {
|
||||
print_obsd_sensors_temp(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(obsd_sensors_fan) {
|
||||
print_obsd_sensors_fan(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(obsd_sensors_volt) {
|
||||
print_obsd_sensors_volt(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(obsd_vendor) {
|
||||
get_obsd_vendor(p, p_max_size);
|
||||
}
|
||||
@ -1077,37 +982,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
new_font(p, obj->data.s);
|
||||
need_to_load_fonts = 1;
|
||||
}
|
||||
#endif /* X11 */
|
||||
OBJ(diskio) {
|
||||
print_diskio(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(diskio_write) {
|
||||
print_diskio_write(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(diskio_read) {
|
||||
print_diskio_read(obj, p, p_max_size);
|
||||
}
|
||||
#ifdef X11
|
||||
OBJ(diskiograph) {
|
||||
print_diskiograph(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(diskiograph_read) {
|
||||
print_diskiograph(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(diskiograph_write) {
|
||||
print_diskiograph(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* X11 */
|
||||
OBJ(downspeed) {
|
||||
print_downspeed(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(downspeedf) {
|
||||
print_downspeedf(obj, p, p_max_size);
|
||||
}
|
||||
#ifdef X11
|
||||
OBJ(downspeedgraph) {
|
||||
print_downspeedgraph(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* X11 */
|
||||
OBJ(else) {
|
||||
/* Since we see you, you're if has not jumped.
|
||||
@ -1120,14 +994,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
OBJ(endif) {
|
||||
/* harmless object, just ignore */
|
||||
}
|
||||
OBJ(addr) {
|
||||
print_addr(obj, p, p_max_size);
|
||||
}
|
||||
#if defined(__linux__)
|
||||
OBJ(addrs) {
|
||||
print_addrs(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* __linux__ */
|
||||
#if defined(IMLIB2) && defined(X11)
|
||||
OBJ(image) {
|
||||
/* doesn't actually draw anything, just queues it omp. the
|
||||
@ -1138,82 +1004,18 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
OBJ(eval) {
|
||||
evaluate(obj->data.s, p, p_max_size);
|
||||
}
|
||||
OBJ(exec) {
|
||||
print_exec(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(execp) {
|
||||
print_execp(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(execgauge) {
|
||||
print_execgauge(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(execbar) {
|
||||
print_execbar(obj, p, p_max_size);
|
||||
}
|
||||
#ifdef X11
|
||||
OBJ(execgraph) {
|
||||
print_execgraph(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* X11 */
|
||||
OBJ(execibar) {
|
||||
print_execibar(obj, p, p_max_size);
|
||||
}
|
||||
#ifdef X11
|
||||
OBJ(execigraph) {
|
||||
print_execigraph(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* X11 */
|
||||
OBJ(execigauge) {
|
||||
print_execigauge(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(execi) {
|
||||
print_execi(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(execpi) {
|
||||
print_execpi(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(texeci) {
|
||||
print_texeci(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(imap_unseen) {
|
||||
print_imap_unseen(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(imap_messages) {
|
||||
print_imap_messages(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(pop3_unseen) {
|
||||
print_pop3_unseen(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(pop3_used) {
|
||||
print_pop3_used(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(fs_bar) {
|
||||
print_fs_bar(obj, 0, p, p_max_size);
|
||||
}
|
||||
OBJ(fs_free) {
|
||||
print_fs_free(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(fs_free_perc) {
|
||||
print_fs_perc(obj, 1, p, p_max_size);
|
||||
}
|
||||
OBJ(fs_size) {
|
||||
print_fs_size(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(fs_type) {
|
||||
print_fs_type(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(fs_used) {
|
||||
print_fs_used(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(fs_bar_free) {
|
||||
print_fs_bar(obj, 1, p, p_max_size);
|
||||
}
|
||||
OBJ(fs_used_perc) {
|
||||
print_fs_perc(obj, 0, p, p_max_size);
|
||||
}
|
||||
OBJ(loadavg) {
|
||||
print_loadavg(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(goto) {
|
||||
new_goto(p, obj->data.i);
|
||||
}
|
||||
@ -1225,53 +1027,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
new_hr(p, obj->data.i);
|
||||
}
|
||||
#endif
|
||||
OBJ(nameserver) {
|
||||
print_nameserver(obj, p, p_max_size);
|
||||
}
|
||||
#ifdef EVE
|
||||
OBJ(eve) {
|
||||
print_eve(obj, p, p_max_size);
|
||||
}
|
||||
#endif
|
||||
#ifdef HAVE_CURL
|
||||
OBJ(curl) {
|
||||
curl_print(obj, p, p_max_size);
|
||||
}
|
||||
#endif
|
||||
#ifdef RSS
|
||||
OBJ(rss) {
|
||||
rss_print_info(obj, p, p_max_size);
|
||||
}
|
||||
#endif
|
||||
#ifdef WEATHER
|
||||
OBJ(weather) {
|
||||
print_weather(obj, p, p_max_size);
|
||||
}
|
||||
#endif
|
||||
#ifdef XOAP
|
||||
OBJ(weather_forecast) {
|
||||
print_weather_forecast(obj, p, p_max_size);
|
||||
}
|
||||
#endif
|
||||
#ifdef HAVE_LUA
|
||||
OBJ(lua) {
|
||||
print_lua(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(lua_parse) {
|
||||
print_lua_parse(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(lua_bar) {
|
||||
print_lua_bar(obj, p, p_max_size);
|
||||
}
|
||||
#ifdef X11
|
||||
OBJ(lua_graph) {
|
||||
print_lua_graph(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* X11 */
|
||||
OBJ(lua_gauge) {
|
||||
print_lua_gauge(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* HAVE_LUA */
|
||||
#ifdef HDDTEMP
|
||||
OBJ(hddtemp) {
|
||||
short val;
|
||||
@ -1291,17 +1046,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
OBJ(voffset) {
|
||||
new_voffset(p, obj->data.i);
|
||||
}
|
||||
#ifdef __linux__
|
||||
OBJ(i2c) {
|
||||
print_sysfs_sensor(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(platform) {
|
||||
print_sysfs_sensor(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(hwmon) {
|
||||
print_sysfs_sensor(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* __linux__ */
|
||||
OBJ(alignr) {
|
||||
new_alignr(p, obj->data.i);
|
||||
}
|
||||
@ -1410,24 +1154,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
}
|
||||
#endif /* X11 */
|
||||
/* mixer stuff */
|
||||
OBJ(mixer) {
|
||||
print_mixer(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mixerl) {
|
||||
print_mixerl(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mixerr) {
|
||||
print_mixerr(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mixerbar) {
|
||||
print_mixer_bar(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mixerlbar) {
|
||||
print_mixerl_bar(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mixerrbar) {
|
||||
print_mixerr_bar(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(if_mixer_mute) {
|
||||
if (!check_mixer_muted(obj)) {
|
||||
DO_JUMP;
|
||||
@ -1479,46 +1205,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
obj->data.s = buf;
|
||||
print_format_time(obj, p, p_max_size);
|
||||
}
|
||||
/* mail stuff */
|
||||
OBJ(mails) {
|
||||
print_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(new_mails) {
|
||||
print_new_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(seen_mails) {
|
||||
print_seen_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(unseen_mails) {
|
||||
print_unseen_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(flagged_mails) {
|
||||
print_flagged_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(unflagged_mails) {
|
||||
print_unflagged_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(forwarded_mails) {
|
||||
print_forwarded_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(unforwarded_mails) {
|
||||
print_unforwarded_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(replied_mails) {
|
||||
print_replied_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(unreplied_mails) {
|
||||
print_unreplied_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(draft_mails) {
|
||||
print_draft_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(trashed_mails) {
|
||||
print_trashed_mails(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mboxscan) {
|
||||
print_mboxscan(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(nodename) {
|
||||
snprintf(p, p_max_size, "%s", cur->uname_s.nodename);
|
||||
}
|
||||
@ -1850,21 +1536,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
OBJ(sysname) {
|
||||
snprintf(p, p_max_size, "%s", cur->uname_s.sysname);
|
||||
}
|
||||
OBJ(time) {
|
||||
print_time(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(utime) {
|
||||
print_utime(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(tztime) {
|
||||
print_tztime(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(totaldown) {
|
||||
print_totaldown(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(totalup) {
|
||||
print_totalup(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(gid_name) {
|
||||
char buf[max_user_text];
|
||||
|
||||
@ -1887,17 +1558,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
DO_JUMP;
|
||||
}
|
||||
}
|
||||
OBJ(upspeed) {
|
||||
print_upspeed(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(upspeedf) {
|
||||
print_upspeedf(obj, p, p_max_size);
|
||||
}
|
||||
#ifdef X11
|
||||
OBJ(upspeedgraph) {
|
||||
print_upspeedgraph(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* X11 */
|
||||
OBJ(uptime_short) {
|
||||
format_seconds_short(p, p_max_size, (int) cur->uptime);
|
||||
}
|
||||
@ -1948,43 +1608,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
#endif /* __FreeBSD__ __OpenBSD__ */
|
||||
|
||||
#ifdef MPD
|
||||
OBJ(mpd_title)
|
||||
print_mpd_title(obj, p, p_max_size);
|
||||
OBJ(mpd_artist)
|
||||
print_mpd_artist(obj, p, p_max_size);
|
||||
OBJ(mpd_album)
|
||||
print_mpd_album(obj, p, p_max_size);
|
||||
OBJ(mpd_random)
|
||||
print_mpd_random(obj, p, p_max_size);
|
||||
OBJ(mpd_repeat)
|
||||
print_mpd_repeat(obj, p, p_max_size);
|
||||
OBJ(mpd_track)
|
||||
print_mpd_track(obj, p, p_max_size);
|
||||
OBJ(mpd_name)
|
||||
print_mpd_name(obj, p, p_max_size);
|
||||
OBJ(mpd_file)
|
||||
print_mpd_file(obj, p, p_max_size);
|
||||
OBJ(mpd_vol)
|
||||
print_mpd_vol(obj, p, p_max_size);
|
||||
OBJ(mpd_bitrate)
|
||||
print_mpd_bitrate(obj, p, p_max_size);
|
||||
OBJ(mpd_status)
|
||||
print_mpd_status(obj, p, p_max_size);
|
||||
OBJ(mpd_elapsed) {
|
||||
print_mpd_elapsed(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mpd_length) {
|
||||
print_mpd_length(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mpd_percent) {
|
||||
print_mpd_percent(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mpd_bar) {
|
||||
print_mpd_bar(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(mpd_smart) {
|
||||
print_mpd_smart(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(if_mpd_playing) {
|
||||
if (!mpd_get_info()->is_playing) {
|
||||
DO_JUMP;
|
||||
@ -2208,13 +1831,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
OBJ(head) {
|
||||
print_tailhead("head", obj, p, p_max_size);
|
||||
}
|
||||
OBJ(lines) {
|
||||
print_lines(obj, p, p_max_size);
|
||||
}
|
||||
|
||||
OBJ(words) {
|
||||
print_words(obj, p, p_max_size);
|
||||
}
|
||||
#ifdef TCP_PORT_MONITOR
|
||||
OBJ(tcp_portmon) {
|
||||
tcp_portmon_action(obj, p, p_max_size);
|
||||
@ -2230,22 +1846,7 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
}
|
||||
#endif /* HAVE_ICONV */
|
||||
|
||||
OBJ(entropy_avail) {
|
||||
print_entropy_avail(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(entropy_perc) {
|
||||
print_entropy_perc(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(entropy_poolsize) {
|
||||
print_entropy_poolsize(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(entropy_bar) {
|
||||
print_entropy_bar(obj, p, p_max_size);
|
||||
}
|
||||
#ifdef IBM
|
||||
OBJ(smapi) {
|
||||
print_smapi(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(if_smapi_bat_installed) {
|
||||
int idx;
|
||||
if(obj->data.s && sscanf(obj->data.s, "%i", &idx) == 1) {
|
||||
@ -2255,18 +1856,6 @@ void generate_text_internal(char *p, int p_max_size,
|
||||
} else
|
||||
NORM_ERR("argument to if_smapi_bat_installed must be an integer");
|
||||
}
|
||||
OBJ(smapi_bat_perc) {
|
||||
print_smapi_bat_perc(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(smapi_bat_temp) {
|
||||
print_smapi_bat_temp(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(smapi_bat_power) {
|
||||
print_smapi_bat_power(obj, p, p_max_size);
|
||||
}
|
||||
OBJ(smapi_bat_bar) {
|
||||
print_smapi_bat_bar(obj, p, p_max_size);
|
||||
}
|
||||
#endif /* IBM */
|
||||
OBJ(include) {
|
||||
if(obj->sub) {
|
||||
|
||||
307
src/core.c
307
src/core.c
@ -182,6 +182,8 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
}
|
||||
END OBJ_ARG(read_tcp, 0, "read_tcp: Needs \"(host) port\" as argument(s)")
|
||||
parse_read_tcp_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_read_tcp;
|
||||
obj->callbacks.free = &free_read_tcp;
|
||||
#if defined(__linux__)
|
||||
END OBJ(voltage_mv, 0)
|
||||
get_cpu_count();
|
||||
@ -193,6 +195,7 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
} else {
|
||||
obj->data.i = atoi(&arg[0]);
|
||||
}
|
||||
obj->callbacks.print = &print_voltage_mv;
|
||||
END OBJ(voltage_v, 0)
|
||||
get_cpu_count();
|
||||
if (!arg || !isdigit(arg[0]) || strlen(arg) >= 2 || atoi(&arg[0]) == 0
|
||||
@ -203,24 +206,33 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
} else {
|
||||
obj->data.i = atoi(&arg[0]);
|
||||
}
|
||||
obj->callbacks.print = &print_voltage_v;
|
||||
|
||||
#ifdef HAVE_IWLIB
|
||||
END OBJ(wireless_essid, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_wireless_essid;
|
||||
END OBJ(wireless_mode, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_wireless_mode;
|
||||
END OBJ(wireless_bitrate, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_wireless_bitrate;
|
||||
END OBJ(wireless_ap, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_wireless_ap;
|
||||
END OBJ(wireless_link_qual, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_wireless_link_qual;
|
||||
END OBJ(wireless_link_qual_max, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_wireless_link_qual_max;
|
||||
END OBJ(wireless_link_qual_perc, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_wireless_link_qual_perc;
|
||||
END OBJ(wireless_link_bar, &update_net_stats)
|
||||
parse_net_stat_bar_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_wireless_link_bar;
|
||||
#endif /* HAVE_IWLIB */
|
||||
|
||||
#endif /* __linux__ */
|
||||
@ -278,21 +290,35 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
END OBJ_ARG(disk_protect, 0, "disk_protect needs an argument")
|
||||
obj->data.s = strndup(dev_name(arg), text_buffer_size);
|
||||
END OBJ(i8k_version, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_version;
|
||||
END OBJ(i8k_bios, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_bios;
|
||||
END OBJ(i8k_serial, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_serial;
|
||||
END OBJ(i8k_cpu_temp, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_cpu_temp;
|
||||
END OBJ(i8k_left_fan_status, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_left_fan_status;
|
||||
END OBJ(i8k_right_fan_status, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_right_fan_status;
|
||||
END OBJ(i8k_left_fan_rpm, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_left_fan_rpm;
|
||||
END OBJ(i8k_right_fan_rpm, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_right_fan_rpm;
|
||||
END OBJ(i8k_ac_status, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_ac_status;
|
||||
END OBJ(i8k_buttons_status, &update_i8k)
|
||||
obj->callbacks.print = &print_i8k_buttons_status;
|
||||
#if defined(IBM)
|
||||
END OBJ(ibm_fan, 0)
|
||||
obj->callbacks.print = &get_ibm_acpi_fan;
|
||||
END OBJ_ARG(ibm_temps, &get_ibm_acpi_temps, "ibm_temps: needs an argument")
|
||||
parse_ibm_temps_arg(obj, arg);
|
||||
obj->callbacks.print = &print_ibm_temps;
|
||||
END OBJ(ibm_volume, 0)
|
||||
obj->callbacks.print = &get_ibm_acpi_volume;
|
||||
END OBJ(ibm_brightness, 0)
|
||||
obj->callbacks.print = &get_ibm_acpi_brightness;
|
||||
#endif
|
||||
/* information from sony_laptop kernel module
|
||||
* /sys/devices/platform/sony-laptop */
|
||||
@ -316,14 +342,18 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
#if (defined(__FreeBSD__) || defined(__linux__))
|
||||
END OBJ_IF_ARG(if_up, 0, "if_up needs an argument")
|
||||
parse_if_up_arg(obj, arg);
|
||||
obj->callbacks.free = &free_if_up;
|
||||
#endif
|
||||
#if defined(__OpenBSD__)
|
||||
END OBJ_ARG(obsd_sensors_temp, 0, "obsd_sensors_temp: needs an argument")
|
||||
parse_obsd_sensor(obj, arg);
|
||||
obj->callbacks.print = &print_obsd_sensors_temp;
|
||||
END OBJ_ARG(obsd_sensors_fan, 0, "obsd_sensors_fan: needs 2 arguments (device and sensor number)")
|
||||
parse_obsd_sensor(obj, arg);
|
||||
obj->callbacks.print = &print_obsd_sensors_fan;
|
||||
END OBJ_ARG(obsd_sensors_volt, 0, "obsd_sensors_volt: needs 2 arguments (device and sensor number)")
|
||||
parse_obsd_sensor(obj, arg);
|
||||
obj->callbacks.print = &print_obsd_sensors_volt;
|
||||
END OBJ(obsd_vendor, 0)
|
||||
END OBJ(obsd_product, 0)
|
||||
#endif /* __OpenBSD__ */
|
||||
@ -359,17 +389,23 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
#endif /* X11 */
|
||||
END OBJ(diskio, &update_diskio)
|
||||
parse_diskio_arg(obj, arg);
|
||||
obj->callbacks.print = &print_diskio;
|
||||
END OBJ(diskio_read, &update_diskio)
|
||||
parse_diskio_arg(obj, arg);
|
||||
obj->callbacks.print = &print_diskio_read;
|
||||
END OBJ(diskio_write, &update_diskio)
|
||||
parse_diskio_arg(obj, arg);
|
||||
obj->callbacks.print = &print_diskio_write;
|
||||
#ifdef X11
|
||||
END OBJ(diskiograph, &update_diskio)
|
||||
parse_diskiograph_arg(obj, arg);
|
||||
obj->callbacks.print = &print_diskiograph;
|
||||
END OBJ(diskiograph_read, &update_diskio)
|
||||
parse_diskiograph_arg(obj, arg);
|
||||
obj->callbacks.print = &print_diskiograph_read;
|
||||
END OBJ(diskiograph_write, &update_diskio)
|
||||
parse_diskiograph_arg(obj, arg);
|
||||
obj->callbacks.print = &print_diskiograph_write;
|
||||
#endif /* X11 */
|
||||
END OBJ(color, 0)
|
||||
#ifdef X11
|
||||
@ -447,11 +483,14 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
obj->data.s = strdup(BUILD_ARCH);
|
||||
END OBJ(downspeed, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_downspeed;
|
||||
END OBJ(downspeedf, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_downspeedf;
|
||||
#ifdef X11
|
||||
END OBJ(downspeedgraph, &update_net_stats)
|
||||
parse_net_stat_graph_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_downspeedgraph;
|
||||
#endif /* X11 */
|
||||
END OBJ(else, 0)
|
||||
obj_be_ifblock_else(ifblock_opaque, obj);
|
||||
@ -465,30 +504,52 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
#endif /* IMLIB2 */
|
||||
END OBJ(exec, 0)
|
||||
scan_exec_arg(obj, arg);
|
||||
obj->callbacks.print = &print_exec;
|
||||
obj->callbacks.free = &free_exec;
|
||||
END OBJ(execp, 0)
|
||||
scan_exec_arg(obj, arg);
|
||||
obj->callbacks.print = &print_execp;
|
||||
obj->callbacks.free = &free_exec;
|
||||
END OBJ(execbar, 0)
|
||||
scan_exec_arg(obj, arg);
|
||||
obj->callbacks.print = &print_execbar;
|
||||
obj->callbacks.free = &free_exec;
|
||||
END OBJ(execgauge, 0)
|
||||
scan_exec_arg(obj, arg);
|
||||
obj->callbacks.print = &print_execgauge;
|
||||
obj->callbacks.free = &free_exec;
|
||||
#ifdef X11
|
||||
END OBJ(execgraph, 0)
|
||||
scan_execgraph_arg(obj, arg);
|
||||
obj->callbacks.print = &print_execgraph;
|
||||
obj->callbacks.free = &free_exec;
|
||||
#endif /* X11 */
|
||||
END OBJ_ARG(execibar, 0, "execibar needs arguments")
|
||||
scan_execi_arg(obj, arg);
|
||||
obj->callbacks.print = &print_execibar;
|
||||
obj->callbacks.free = &free_execi;
|
||||
#ifdef X11
|
||||
END OBJ_ARG(execigraph, 0, "execigraph needs arguments")
|
||||
scan_execgraph_arg(obj, arg);
|
||||
obj->callbacks.print = &print_execigraph;
|
||||
obj->callbacks.free = &free_execi;
|
||||
#endif /* X11 */
|
||||
END OBJ_ARG(execigauge, 0, "execigauge needs arguments")
|
||||
scan_execi_arg(obj, arg);
|
||||
obj->callbacks.print = &print_execigauge;
|
||||
obj->callbacks.free = &free_execi;
|
||||
END OBJ_ARG(execi, 0, "execi needs arguments")
|
||||
scan_execi_arg(obj, arg);
|
||||
obj->callbacks.print = &print_execi;
|
||||
obj->callbacks.free = &free_execi;
|
||||
END OBJ_ARG(execpi, 0, "execpi needs arguments")
|
||||
scan_execi_arg(obj, arg);
|
||||
obj->callbacks.print = &print_execpi;
|
||||
obj->callbacks.free = &free_execi;
|
||||
END OBJ_ARG(texeci, 0, "texeci needs arguments")
|
||||
scan_execi_arg(obj, arg);
|
||||
obj->callbacks.print = &print_texeci;
|
||||
obj->callbacks.free = &free_execi;
|
||||
END OBJ(pre_exec, 0)
|
||||
scan_pre_exec_arg(obj, arg);
|
||||
END OBJ(fs_bar, &update_fs_stats)
|
||||
@ -497,20 +558,25 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
init_fs_bar(obj, arg);
|
||||
END OBJ(fs_free, &update_fs_stats)
|
||||
init_fs(obj, arg);
|
||||
obj->callbacks.print = &print_fs_free;
|
||||
END OBJ(fs_used_perc, &update_fs_stats)
|
||||
init_fs(obj, arg);
|
||||
END OBJ(fs_free_perc, &update_fs_stats)
|
||||
init_fs(obj, arg);
|
||||
END OBJ(fs_size, &update_fs_stats)
|
||||
init_fs(obj, arg);
|
||||
obj->callbacks.print = &print_fs_size;
|
||||
END OBJ(fs_type, &update_fs_stats)
|
||||
init_fs(obj, arg);
|
||||
obj->callbacks.print = &print_fs_type;
|
||||
END OBJ(fs_used, &update_fs_stats)
|
||||
init_fs(obj, arg);
|
||||
obj->callbacks.print = &print_fs_used;
|
||||
END OBJ(hr, 0)
|
||||
obj->data.i = arg ? atoi(arg) : 1;
|
||||
END OBJ(nameserver, &update_dns_data)
|
||||
parse_nameserver_arg(obj, arg);
|
||||
obj->callbacks.print = &print_nameserver;
|
||||
END OBJ(offset, 0)
|
||||
obj->data.i = arg ? atoi(arg) : 1;
|
||||
END OBJ(voffset, 0)
|
||||
@ -524,10 +590,16 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
#ifdef __linux__
|
||||
END OBJ_ARG(i2c, 0, "i2c needs arguments")
|
||||
parse_i2c_sensor(obj, arg);
|
||||
obj->callbacks.print = &print_sysfs_sensor;
|
||||
obj->callbacks.free = &free_sysfs_sensor;
|
||||
END OBJ_ARG(platform, 0, "platform needs arguments")
|
||||
parse_platform_sensor(obj, arg);
|
||||
obj->callbacks.print = &print_sysfs_sensor;
|
||||
obj->callbacks.free = &free_sysfs_sensor;
|
||||
END OBJ_ARG(hwmon, 0, "hwmon needs argumanets")
|
||||
parse_hwmon_sensor(obj, arg);
|
||||
obj->callbacks.print = &print_sysfs_sensor;
|
||||
obj->callbacks.free = &free_sysfs_sensor;
|
||||
END
|
||||
/* we have four different types of top (top, top_mem, top_time and top_io). To
|
||||
* avoid having almost-same code four times, we have this special
|
||||
@ -540,19 +612,26 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
}
|
||||
} else OBJ(addr, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_addr;
|
||||
END OBJ(addrs, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_addrs;
|
||||
#endif /* __linux__ */
|
||||
END OBJ_ARG(tail, 0, "tail needs arguments")
|
||||
init_tailhead("tail", arg, obj, free_at_crash);
|
||||
obj->callbacks.free = &free_tailhead;
|
||||
END OBJ_ARG(head, 0, "head needs arguments")
|
||||
init_tailhead("head", arg, obj, free_at_crash);
|
||||
obj->callbacks.free = &free_tailhead;
|
||||
END OBJ_ARG(lines, 0, "lines needs an argument")
|
||||
obj->data.s = strndup(arg, text_buffer_size);
|
||||
obj->callbacks.print = &print_lines;
|
||||
END OBJ_ARG(words, 0, "words needs a argument")
|
||||
obj->data.s = strndup(arg, text_buffer_size);
|
||||
obj->callbacks.print = &print_words;
|
||||
END OBJ(loadavg, &update_load_average)
|
||||
scan_loadavg_arg(obj, arg);
|
||||
obj->callbacks.print = &print_loadavg;
|
||||
END OBJ_IF_ARG(if_empty, 0, "if_empty needs an argument")
|
||||
obj->sub = malloc(sizeof(struct text_object));
|
||||
extract_variable_text_internal(obj->sub, arg);
|
||||
@ -578,30 +657,56 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
END OBJ(machine, 0)
|
||||
END OBJ(mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(new_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_new_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(seen_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_seen_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(unseen_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_unseen_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(flagged_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_flagged_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(unflagged_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_unflagged_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(forwarded_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_forwarded_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(unforwarded_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_unforwarded_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(replied_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_replied_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(unreplied_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_unreplied_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(draft_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_draft_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(trashed_mails, 0)
|
||||
parse_local_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_trashed_mails;
|
||||
obj->callbacks.free = &free_local_mails;
|
||||
END OBJ(mboxscan, 0)
|
||||
parse_mboxscan_arg(obj, arg);
|
||||
obj->callbacks.print = &print_mboxscan;
|
||||
obj->callbacks.free = &free_mboxscan;
|
||||
END OBJ(mem, &update_meminfo)
|
||||
END OBJ(memeasyfree, &update_meminfo)
|
||||
END OBJ(memfree, &update_meminfo)
|
||||
@ -620,16 +725,22 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
#endif /* X11*/
|
||||
END OBJ(mixer, 0)
|
||||
parse_mixer_arg(obj, arg);
|
||||
obj->callbacks.print = &print_mixer;
|
||||
END OBJ(mixerl, 0)
|
||||
parse_mixer_arg(obj, arg);
|
||||
obj->callbacks.print = &print_mixerl;
|
||||
END OBJ(mixerr, 0)
|
||||
parse_mixer_arg(obj, arg);
|
||||
obj->callbacks.print = &print_mixerr;
|
||||
END OBJ(mixerbar, 0)
|
||||
scan_mixer_bar(obj, arg);
|
||||
obj->callbacks.print = &print_mixer_bar;
|
||||
END OBJ(mixerlbar, 0)
|
||||
scan_mixer_bar(obj, arg);
|
||||
obj->callbacks.print = &print_mixerl_bar;
|
||||
END OBJ(mixerrbar, 0)
|
||||
scan_mixer_bar(obj, arg);
|
||||
obj->callbacks.print = &print_mixerr_bar;
|
||||
END OBJ_IF(if_mixer_mute, 0)
|
||||
parse_mixer_arg(obj, arg);
|
||||
#ifdef X11
|
||||
@ -801,10 +912,16 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
END OBJ(sysname, 0)
|
||||
END OBJ(time, 0)
|
||||
scan_time(obj, arg);
|
||||
obj->callbacks.print = &print_time;
|
||||
obj->callbacks.free = &free_time;
|
||||
END OBJ(utime, 0)
|
||||
scan_time(obj, arg);
|
||||
obj->callbacks.print = &print_utime;
|
||||
obj->callbacks.free = &free_time;
|
||||
END OBJ(tztime, 0)
|
||||
scan_tztime(obj, arg);
|
||||
obj->callbacks.print = &print_tztime;
|
||||
obj->callbacks.free = &free_tztime;
|
||||
#ifdef HAVE_ICONV
|
||||
END OBJ_ARG(iconv_start, 0, "Iconv requires arguments")
|
||||
init_iconv_start(obj, free_at_crash, arg);
|
||||
@ -813,8 +930,10 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
#endif
|
||||
END OBJ(totaldown, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_totaldown;
|
||||
END OBJ(totalup, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_totalup;
|
||||
END OBJ(updates, 0)
|
||||
END OBJ_IF(if_updatenr, 0)
|
||||
obj->data.i = arg ? atoi(arg) : 0;
|
||||
@ -826,11 +945,14 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
obj->data.i = arg ? atoi(arg) : 0;
|
||||
END OBJ(upspeed, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_upspeed;
|
||||
END OBJ(upspeedf, &update_net_stats)
|
||||
parse_net_stat_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_upspeedf;
|
||||
#ifdef X11
|
||||
END OBJ(upspeedgraph, &update_net_stats)
|
||||
parse_net_stat_graph_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_upspeedgraph;
|
||||
#endif
|
||||
END OBJ(uptime_short, &update_uptime)
|
||||
END OBJ(uptime, &update_uptime)
|
||||
@ -852,23 +974,35 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
#endif /* __FreeBSD__ */
|
||||
END OBJ(imap_unseen, 0)
|
||||
parse_imap_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_imap_unseen;
|
||||
obj->callbacks.free = &free_mail_obj;
|
||||
END OBJ(imap_messages, 0)
|
||||
parse_imap_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_imap_messages;
|
||||
obj->callbacks.free = &free_mail_obj;
|
||||
END OBJ(pop3_unseen, 0)
|
||||
parse_pop3_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_pop3_unseen;
|
||||
obj->callbacks.free = &free_mail_obj;
|
||||
END OBJ(pop3_used, 0)
|
||||
parse_pop3_mail_args(obj, arg);
|
||||
obj->callbacks.print = &print_pop3_used;
|
||||
obj->callbacks.free = &free_mail_obj;
|
||||
#ifdef IBM
|
||||
END OBJ_ARG(smapi, 0, "smapi needs an argument")
|
||||
obj->data.s = strndup(arg, text_buffer_size);
|
||||
obj->callbacks.print = &print_smapi;
|
||||
END OBJ_IF_ARG(if_smapi_bat_installed, 0, "if_smapi_bat_installed needs an argument")
|
||||
obj->data.s = strndup(arg, text_buffer_size);
|
||||
END OBJ_ARG(smapi_bat_perc, 0, "smapi_bat_perc needs an argument")
|
||||
obj->data.s = strndup(arg, text_buffer_size);
|
||||
obj->callbacks.print = &print_smapi_bat_perc;
|
||||
END OBJ_ARG(smapi_bat_temp, 0, "smapi_bat_temp needs an argument")
|
||||
obj->data.s = strndup(arg, text_buffer_size);
|
||||
obj->callbacks.print = &print_smapi_bat_temp;
|
||||
END OBJ_ARG(smapi_bat_power, 0, "smapi_bat_power needs an argument")
|
||||
obj->data.s = strndup(arg, text_buffer_size);
|
||||
obj->callbacks.print = &print_smapi_bat_power;
|
||||
END OBJ_ARG(smapi_bat_bar, 0, "smapi_bat_bar needs an argument")
|
||||
int cnt;
|
||||
if(sscanf(arg, "%i %n", &obj->data.i, &cnt) <= 0) {
|
||||
@ -876,6 +1010,7 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
obj->data.i = -1;
|
||||
} else
|
||||
arg = scan_bar(obj, arg + cnt);
|
||||
obj->callbacks.print = &print_smapi_bat_bar;
|
||||
#endif /* IBM */
|
||||
#ifdef MPD
|
||||
#define mpd_set_maxlen(name) \
|
||||
@ -890,35 +1025,59 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
END OBJ(mpd_artist, &update_mpd)
|
||||
mpd_set_maxlen(mpd_artist);
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_artist;
|
||||
END OBJ(mpd_title, &update_mpd)
|
||||
mpd_set_maxlen(mpd_title);
|
||||
init_mpd();
|
||||
END OBJ(mpd_random, &update_mpd) init_mpd();
|
||||
END OBJ(mpd_repeat, &update_mpd) init_mpd();
|
||||
END OBJ(mpd_elapsed, &update_mpd) init_mpd();
|
||||
END OBJ(mpd_length, &update_mpd) init_mpd();
|
||||
obj->callbacks.print = &print_mpd_title;
|
||||
END OBJ(mpd_random, &update_mpd)
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_random;
|
||||
END OBJ(mpd_repeat, &update_mpd)
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_repeat;
|
||||
END OBJ(mpd_elapsed, &update_mpd)
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_elapsed;
|
||||
END OBJ(mpd_length, &update_mpd)
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_length;
|
||||
END OBJ(mpd_track, &update_mpd)
|
||||
mpd_set_maxlen(mpd_track);
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_track;
|
||||
END OBJ(mpd_name, &update_mpd)
|
||||
mpd_set_maxlen(mpd_name);
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_name;
|
||||
END OBJ(mpd_file, &update_mpd)
|
||||
mpd_set_maxlen(mpd_file);
|
||||
init_mpd();
|
||||
END OBJ(mpd_percent, &update_mpd) init_mpd();
|
||||
obj->callbacks.print = &print_mpd_file;
|
||||
END OBJ(mpd_percent, &update_mpd)
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_percent;
|
||||
END OBJ(mpd_album, &update_mpd)
|
||||
mpd_set_maxlen(mpd_album);
|
||||
init_mpd();
|
||||
END OBJ(mpd_vol, &update_mpd) init_mpd();
|
||||
END OBJ(mpd_bitrate, &update_mpd) init_mpd();
|
||||
END OBJ(mpd_status, &update_mpd) init_mpd();
|
||||
obj->callbacks.print = &print_mpd_album;
|
||||
END OBJ(mpd_vol, &update_mpd)
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_vol;
|
||||
END OBJ(mpd_bitrate, &update_mpd)
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_bitrate;
|
||||
END OBJ(mpd_status, &update_mpd)
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_status;
|
||||
END OBJ(mpd_bar, &update_mpd)
|
||||
scan_bar(obj, arg);
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_bar;
|
||||
END OBJ(mpd_smart, &update_mpd)
|
||||
mpd_set_maxlen(mpd_smart);
|
||||
init_mpd();
|
||||
obj->callbacks.print = &print_mpd_smart;
|
||||
END OBJ_IF(if_mpd_playing, &update_mpd)
|
||||
init_mpd();
|
||||
#undef mpd_set_maxlen
|
||||
@ -999,28 +1158,40 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
#ifdef EVE
|
||||
END OBJ_ARG(eve, 0, "eve needs arguments: <userid> <apikey> <characterid>")
|
||||
scan_eve(obj, arg);
|
||||
obj->callbacks.print = &print_eve;
|
||||
obj->callbacks.free = &free_eve;
|
||||
#endif
|
||||
#ifdef HAVE_CURL
|
||||
END OBJ_ARG(curl, 0, "curl needs arguments: <uri> <interval in minutes>")
|
||||
curl_parse_arg(obj, arg);
|
||||
obj->callbacks.print = &curl_print;
|
||||
obj->callbacks.free = &curl_obj_free;
|
||||
#endif
|
||||
#ifdef RSS
|
||||
END OBJ_ARG(rss, 0, "rss needs arguments: <uri> <interval in minutes> <action> [act_par] [spaces in front]")
|
||||
rss_scan_arg(obj, arg);
|
||||
obj->callbacks.print = &rss_print_info;
|
||||
obj->callbacks.free = &rss_free_obj_info;
|
||||
#endif
|
||||
#ifdef WEATHER
|
||||
END OBJ_ARG(weather, 0, "weather needs arguments: <uri> <locID> <data_type> [interval in minutes]")
|
||||
scan_weather_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_weather;
|
||||
obj->callbacks.free = &free_weather;
|
||||
#endif
|
||||
#ifdef XOAP
|
||||
END OBJ_ARG(weather_forecast, 0, "weather_forecast needs arguments: <uri> <locID> <day> <data_type> [interval in minutes]")
|
||||
scan_weather_forecast_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.print = &print_weather_forecast;
|
||||
obj->callbacks.free = &free_weather;
|
||||
#endif
|
||||
#ifdef HAVE_LUA
|
||||
END OBJ_ARG(lua, 0, "lua needs arguments: <function name> [function parameters]")
|
||||
obj->data.s = strndup(arg, text_buffer_size);
|
||||
obj->callbacks.print = &print_lua;
|
||||
END OBJ_ARG(lua_parse, 0, "lua_parse needs arguments: <function name> [function parameters]")
|
||||
obj->data.s = strndup(arg, text_buffer_size);
|
||||
obj->callbacks.print = &print_lua_parse;
|
||||
END OBJ_ARG(lua_bar, 0, "lua_bar needs arguments: <height>,<width> <function name> [function parameters]")
|
||||
arg = scan_bar(obj, arg);
|
||||
if(arg) {
|
||||
@ -1028,6 +1199,7 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
} else {
|
||||
CRIT_ERR(obj, free_at_crash, "lua_bar needs arguments: <height>,<width> <function name> [function parameters]");
|
||||
}
|
||||
obj->callbacks.print = &print_lua_bar;
|
||||
#ifdef X11
|
||||
END OBJ_ARG(lua_graph, 0, "lua_graph needs arguments: <function name> [height],[width] [gradient colour 1] [gradient colour 2] [scale] [-t] [-l]")
|
||||
char *buf = 0;
|
||||
@ -1037,6 +1209,7 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
} else {
|
||||
CRIT_ERR(obj, free_at_crash, "lua_graph needs arguments: <function name> [height],[width] [gradient colour 1] [gradient colour 2] [scale] [-t] [-l]");
|
||||
}
|
||||
obj->callbacks.print = &print_lua_graph;
|
||||
#endif /* X11 */
|
||||
END OBJ_ARG(lua_gauge, 0, "lua_gauge needs arguments: <height>,<width> <function name> [function parameters]")
|
||||
arg = scan_gauge(obj, arg);
|
||||
@ -1045,6 +1218,7 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
} else {
|
||||
CRIT_ERR(obj, free_at_crash, "lua_gauge needs arguments: <height>,<width> <function name> [function parameters]");
|
||||
}
|
||||
obj->callbacks.print = &print_lua_gauge;
|
||||
#endif /* HAVE_LUA */
|
||||
#ifdef HDDTEMP
|
||||
END OBJ(hddtemp, &update_hddtemp)
|
||||
@ -1054,12 +1228,17 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
#ifdef TCP_PORT_MONITOR
|
||||
END OBJ_ARG(tcp_portmon, &tcp_portmon_update, "tcp_portmon: needs arguments")
|
||||
tcp_portmon_init(obj, arg);
|
||||
obj->callbacks.free = &tcp_portmon_free;
|
||||
#endif /* TCP_PORT_MONITOR */
|
||||
END OBJ(entropy_avail, &update_entropy)
|
||||
obj->callbacks.print = &print_entropy_avail;
|
||||
END OBJ(entropy_perc, &update_entropy)
|
||||
obj->callbacks.print = &print_entropy_perc;
|
||||
END OBJ(entropy_poolsize, &update_entropy)
|
||||
obj->callbacks.print = &print_entropy_poolsize;
|
||||
END OBJ(entropy_bar, &update_entropy)
|
||||
scan_bar(obj, arg);
|
||||
obj->callbacks.print = &print_entropy_bar;
|
||||
END OBJ_ARG(include, 0, "include needs a argument")
|
||||
struct conftree *leaf = conftree_add(currentconffile, arg);
|
||||
if(leaf) {
|
||||
@ -1082,14 +1261,17 @@ struct text_object *construct_text_object(const char *s, const char *arg, long
|
||||
extract_variable_text_internal(obj->sub, arg);
|
||||
END OBJ(scroll, 0)
|
||||
parse_scroll_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.free = &free_scroll;
|
||||
END OBJ_ARG(combine, 0, "combine needs arguments: <text1> <text2>")
|
||||
parse_combine_arg(obj, arg, free_at_crash);
|
||||
obj->callbacks.free = &free_combine;
|
||||
#ifdef NVIDIA
|
||||
END OBJ_ARG(nvidia, 0, "nvidia needs an argument")
|
||||
if (set_nvidia_type(obj, arg)) {
|
||||
CRIT_ERR(obj, free_at_crash, "nvidia: invalid argument"
|
||||
" specified: '%s'\n", arg);
|
||||
}
|
||||
obj->callbacks.free = &free_nvidia;
|
||||
#endif /* NVIDIA */
|
||||
#ifdef APCUPSD
|
||||
END OBJ_ARG(apcupsd, &update_apcupsd, "apcupsd needs arguments: <host> <port>")
|
||||
@ -1360,13 +1542,6 @@ void free_text_objects(struct text_object *root, int internal)
|
||||
close(data.i);
|
||||
break;
|
||||
#endif /* !__OpenBSD__ */
|
||||
#ifdef __linux__
|
||||
case OBJ_i2c:
|
||||
case OBJ_platform:
|
||||
case OBJ_hwmon:
|
||||
free_sysfs_sensor(obj);
|
||||
break;
|
||||
#endif /* __linux__ */
|
||||
case OBJ_cmdline_to_pid:
|
||||
free(data.s);
|
||||
break;
|
||||
@ -1423,39 +1598,6 @@ void free_text_objects(struct text_object *root, int internal)
|
||||
free(obj->sub);
|
||||
}
|
||||
break;
|
||||
case OBJ_read_tcp:
|
||||
free_read_tcp(obj);
|
||||
break;
|
||||
case OBJ_time:
|
||||
case OBJ_utime:
|
||||
free_time(obj);
|
||||
break;
|
||||
case OBJ_tztime:
|
||||
free_tztime(obj);
|
||||
break;
|
||||
case OBJ_mboxscan:
|
||||
free_mboxscan(obj);
|
||||
break;
|
||||
case OBJ_mails:
|
||||
case OBJ_new_mails:
|
||||
case OBJ_seen_mails:
|
||||
case OBJ_unseen_mails:
|
||||
case OBJ_flagged_mails:
|
||||
case OBJ_unflagged_mails:
|
||||
case OBJ_forwarded_mails:
|
||||
case OBJ_unforwarded_mails:
|
||||
case OBJ_replied_mails:
|
||||
case OBJ_unreplied_mails:
|
||||
case OBJ_draft_mails:
|
||||
case OBJ_trashed_mails:
|
||||
free_local_mails(obj);
|
||||
break;
|
||||
case OBJ_imap_unseen:
|
||||
case OBJ_imap_messages:
|
||||
case OBJ_pop3_unseen:
|
||||
case OBJ_pop3_used:
|
||||
free_mail_obj(obj);
|
||||
break;
|
||||
case OBJ_if_empty:
|
||||
case OBJ_if_match:
|
||||
free_text_objects(obj->sub, 1);
|
||||
@ -1466,25 +1608,12 @@ void free_text_objects(struct text_object *root, int internal)
|
||||
case OBJ_if_running:
|
||||
free(data.s);
|
||||
break;
|
||||
case OBJ_head:
|
||||
case OBJ_tail:
|
||||
free_tailhead(obj);
|
||||
break;
|
||||
case OBJ_text:
|
||||
case OBJ_font:
|
||||
case OBJ_image:
|
||||
case OBJ_eval:
|
||||
free(data.s);
|
||||
break;
|
||||
case OBJ_exec:
|
||||
case OBJ_execbar:
|
||||
case OBJ_execgauge:
|
||||
#ifdef X11
|
||||
case OBJ_execgraph:
|
||||
#endif
|
||||
case OBJ_execp:
|
||||
free_exec(obj);
|
||||
break;
|
||||
#ifdef HAVE_ICONV
|
||||
case OBJ_iconv_start:
|
||||
free_iconv();
|
||||
@ -1504,11 +1633,6 @@ void free_text_objects(struct text_object *root, int internal)
|
||||
free(data.s);
|
||||
break;
|
||||
#endif
|
||||
#if (defined(__FreeBSD__) || defined(__linux__))
|
||||
case OBJ_if_up:
|
||||
free_if_up(obj);
|
||||
break;
|
||||
#endif
|
||||
#ifdef XMMS2
|
||||
case OBJ_xmms2_artist:
|
||||
if (info.xmms2.artist) {
|
||||
@ -1588,31 +1712,6 @@ void free_text_objects(struct text_object *root, int internal)
|
||||
case OBJ_bmpx_bitrate:
|
||||
break;
|
||||
#endif
|
||||
#ifdef EVE
|
||||
case OBJ_eve:
|
||||
free_eve(obj);
|
||||
break;
|
||||
#endif
|
||||
#ifdef HAVE_CURL
|
||||
case OBJ_curl:
|
||||
curl_obj_free(obj);
|
||||
break;
|
||||
#endif
|
||||
#ifdef RSS
|
||||
case OBJ_rss:
|
||||
rss_free_obj_info(obj);
|
||||
break;
|
||||
#endif
|
||||
#ifdef WEATHER
|
||||
case OBJ_weather:
|
||||
free_weather(obj);
|
||||
break;
|
||||
#endif
|
||||
#ifdef XOAP
|
||||
case OBJ_weather_forecast:
|
||||
free_weather(obj);
|
||||
break;
|
||||
#endif
|
||||
#ifdef HAVE_LUA
|
||||
case OBJ_lua:
|
||||
case OBJ_lua_parse:
|
||||
@ -1637,16 +1736,6 @@ void free_text_objects(struct text_object *root, int internal)
|
||||
free(data.s);
|
||||
break;
|
||||
#endif /* !__OpenBSD__ */
|
||||
case OBJ_execpi:
|
||||
case OBJ_execi:
|
||||
case OBJ_execibar:
|
||||
case OBJ_texeci:
|
||||
#ifdef X11
|
||||
case OBJ_execigraph:
|
||||
#endif /* X11 */
|
||||
case OBJ_execigauge:
|
||||
free_execi(obj);
|
||||
break;
|
||||
case OBJ_nameserver:
|
||||
free_dns_data();
|
||||
break;
|
||||
@ -1712,11 +1801,6 @@ void free_text_objects(struct text_object *root, int internal)
|
||||
free(data.s);
|
||||
break;
|
||||
#endif /* IBM */
|
||||
#ifdef NVIDIA
|
||||
case OBJ_nvidia:
|
||||
free_nvidia(obj);
|
||||
break;
|
||||
#endif /* NVIDIA */
|
||||
#ifdef MPD
|
||||
case OBJ_mpd_title:
|
||||
case OBJ_mpd_artist:
|
||||
@ -1761,12 +1845,6 @@ void free_text_objects(struct text_object *root, int internal)
|
||||
free(obj->sub);
|
||||
}
|
||||
break;
|
||||
case OBJ_scroll:
|
||||
free_scroll(obj);
|
||||
break;
|
||||
case OBJ_combine:
|
||||
free_combine(obj);
|
||||
break;
|
||||
#ifdef APCUPSD
|
||||
case OBJ_apcupsd:
|
||||
case OBJ_apcupsd_name:
|
||||
@ -1787,11 +1865,6 @@ void free_text_objects(struct text_object *root, int internal)
|
||||
case OBJ_apcupsd_lastxfer:
|
||||
break;
|
||||
#endif /* APCUPSD */
|
||||
#ifdef TCP_PORT_MONITOR
|
||||
case OBJ_tcp_portmon:
|
||||
tcp_portmon_free(obj);
|
||||
break;
|
||||
#endif /* TCP_PORT_MONITOR */
|
||||
#ifdef X11
|
||||
case OBJ_desktop:
|
||||
case OBJ_desktop_number:
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user