int BatteryMonitor::update_icon_and_tooltip(void) {
/* in case connection failed somehow */
if(!con.connected()) {
label("0");
return 0;
}
E_RETURN_VAL_IF_FAIL(batts.size() > 0, 0);
double p = 0, ret = 0;
if(batts.size() == 1) {
E_RETURN_VAL_IF_FAIL(get_percentage(con, batts.front().path(), &ret), 0);
p = ret;
tooltip_printf(_("Battery %s: %i%%"), get_state_str(con, batts.front().path()), (int)ret);
} else {
for(BatteryListIt it = batts.begin(), ite = batts.end(); it != ite; ++it) {
if(!get_percentage(con, it->path(), &ret)) continue;
p += ret;
}
p /= batts.size();
tooltip_printf(_("%i batteries: %i%%"), batts.size(), (int)p);
}
set_icon(p);
/* returning state is mainly for signal_cb() */
return 1;
}
bool DesktopFile::path(char* val, int len) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
E_RETURN_VAL_IF_FAIL(dtype == DESK_FILE_TYPE_APPLICATION, false);
if(!Config::get(ENTRY_SECT, "Path", val, len))
return false;
return true;
}
bool DesktopFile::url(char* val, int len) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
E_RETURN_VAL_IF_FAIL(dtype == DESK_FILE_TYPE_LINK, false);
if(!Config::get(ENTRY_SECT, "URL", val, len))
return false;
return true;
}
bool Theme::load(const char *f) {
E_RETURN_VAL_IF_FAIL(f != NULL, false);
/* do not allow loading if clear() wasn't called before */
E_RETURN_VAL_IF_FAIL(priv->sc == NULL, false);
priv->is_loaded = false;
init_interpreter();
scheme *ss = priv->sc;
/*
* Determine from which directory we loads file, and set that file as base directory
* where '(include)' statement can search additional files. Include uses 'private::theme.search-path'.
*/
char *path = edelib_strndup(f, PATH_MAX);
if(!path)
E_FATAL(E_STRLOC ": No memory\n");
char *dir = local_dirname(path);
/* If returned name is the same as file, dirname wasn't found directory name in given path. */
if(strcmp(dir, f) != 0) {
pointer sym = mk_symbol(ss, "private:theme.search-path");
edelib_scheme_define(ss, ss->global_env, sym, mk_string(ss, dir));
ss->vptr->setimmutable(sym);
}
/* scheme copies path, so we do not need it any more */
free(path);
FILE *fd = fopen(f, "r");
if(!fd) {
edelib_scheme_deinit(ss);
free(ss);
priv->sc = 0;
return false;
}
edelib_scheme_load_named_file(ss, fd, f);
fclose(fd);
if(ss->no_memory) {
E_WARNING(E_STRLOC ": No memory to load theme source in interpreter\n");
return false;
}
if(ss->retcode != 0)
return false;
/* fetch common variables */
priv->name = get_string_var(ss, "private:theme.name");
priv->author = get_string_var(ss, "private:theme.author");
priv->sample = get_string_var(ss, "private:theme.sample");
priv->is_loaded = true;
return true;
}
bool Theme::get_item(const char *style_name, const char *item_name, char *ret, unsigned int sz) {
E_RETURN_VAL_IF_FAIL(priv->is_loaded == true, false);
E_RETURN_VAL_IF_FAIL(style_name != NULL, false);
E_RETURN_VAL_IF_FAIL(item_name != NULL, false);
E_RETURN_VAL_IF_FAIL(ret!= NULL, false);
E_RETURN_VAL_IF_FAIL(sz > 0, false);
scheme *ss = priv->sc;
pointer style = get_style_once(priv, ss, style_name);
if(style == ss->NIL)
return false;
pointer lst, item, val;
char *ret_str = NULL;
/*
* 'style' has the following list: '((item value) (item value)...)'
* First item is a symbol and the second is string. Although tinyscheme displays them in the same way,
* they are different types and appropriate functions must be called during conversion.
*/
while(style != ss->NIL) {
lst = ss->vptr->pair_car(style);
item = ss->vptr->pair_car(lst);
val = ss->vptr->pair_car(ss->vptr->pair_cdr(lst));
/* check if we found matching item */
if(ss->vptr->is_symbol(item) && strcmp(item_name, ss->vptr->symname(item)) == 0) {
#if THEME_EVAL_VALUE_PAIR
/*
* Now, see if item value is function; if is true, evaluate it and return the result.
* In this case, result must be a string.
*/
if(ss->vptr->is_pair(val))
val = scheme_eval(ss, val);
#endif
/* if it is not string, simply continue until find item with the string value */
if(ss->vptr->is_string(val)) {
ret_str = ss->vptr->string_value(val);
break;
}
}
style = ss->vptr->pair_cdr(style);
}
if(ret_str) {
strncpy(ret, ret_str, sz);
if(sz > 0)
ret[sz - 1] = '\0';
}
return (ret_str != NULL);
}
static bool is_battery(EdbusConnection &con, const char *path) {
EdbusMessage reply;
E_RETURN_VAL_IF_FAIL(bus_property_get(con, UPOWER_SERVICE, path, UPOWER_INTERFACE, "Type", &reply), false);
EdbusMessage::const_iterator it = reply.begin();
E_RETURN_VAL_IF_FAIL(it->is_variant(), false);
EdbusVariant v = it->to_variant();
E_RETURN_VAL_IF_FAIL(v.value.is_uint32(), false);
return v.value.to_uint32() == UPOWER_TYPE_BATTERY;
}
static bool get_state(EdbusConnection &con, const char *path, int *ret) {
EdbusMessage reply;
E_RETURN_VAL_IF_FAIL(bus_property_get(con, UPOWER_SERVICE, path, UPOWER_INTERFACE, "State", &reply), false);
EdbusMessage::const_iterator it = reply.begin();
E_RETURN_VAL_IF_FAIL(it->is_variant(), false);
EdbusVariant v = it->to_variant();
E_RETURN_VAL_IF_FAIL(v.value.is_uint32(), false);
*ret = v.value.to_uint32();
return true;
}
DesktopIcon *Desktop::read_desktop_file(const char *path, const char *base, DesktopConfig *pos) {
DesktopIcon *ret = NULL;
if(file_test(path, FILE_TEST_IS_DIR)) {
ret = new DesktopIcon(_("No Name"));
ret->set_icon_type(DESKTOP_ICON_TYPE_FOLDER);
/* hardcoded */
ret->set_image("folder");
/* copy label explicitly, as DesktopIcon() will only store a pointer */
ret->copy_label(base);
} else {
/*
* try to load it as plain .desktop file by looking only at extension
* TODO: MimeType can be used here too
*/
if(!str_ends(path, EDE_DESKTOP_DESKTOP_EXT))
return ret;
DesktopFile df;
char buf[PATH_MAX];
E_RETURN_VAL_IF_FAIL(df.load(path), ret);
E_RETURN_VAL_IF_FAIL(df.type() != DESK_FILE_TYPE_UNKNOWN, ret);
ret = new DesktopIcon(_("No Name"));
ret->set_icon_type(DESKTOP_ICON_TYPE_NORMAL);
if(df.name(buf, sizeof(buf))) ret->copy_label(buf);
ret->set_image(df.icon(buf, sizeof(buf)) ? buf : NULL);
if(df.comment(buf, sizeof(buf))) ret->set_tooltip(buf);
}
/* try to put random icon position in the middle of the desktop, so it is easier to notice */
int X = (rand() % (w() / 4)) + (w() / 4);
int Y = (rand() % (h() / 4)) + (h() / 4);
/* lookup icons locations if possible */
if(base && pos && *pos) {
pos->get(base, "X", X, X);
pos->get(base, "Y", Y, Y);
}
E_DEBUG("Setting icon '%s' (%i,%i)\n", base, X, Y);
ret->position(X, Y);
/* use loaded icon options */
ret->set_options(icon_opts);
ret->set_path(path);
return ret;
}
static pointer edelib_scheme_clock_diff(scheme *s, pointer args) {
pointer a, b;
a = edelib_scheme_pair_car(s, args);
E_RETURN_VAL_IF_FAIL(a != s->NIL, s->F);
E_RETURN_VAL_IF_FAIL(edelib_scheme_is_double(s, a), s->F);
args = edelib_scheme_pair_cdr(s, args);
b = edelib_scheme_pair_car(s, args);
E_RETURN_VAL_IF_FAIL(b != s->NIL, s->F);
E_RETURN_VAL_IF_FAIL(edelib_scheme_is_double(s, b), s->F);
double d = (double)((edelib_scheme_double_value(s, a) - edelib_scheme_double_value(s, b)) / CLOCKS_PER_SEC);
return edelib_scheme_mk_double(s, d);
}
bool DesktopFile::terminal(void) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
bool ret;
Config::get(ENTRY_SECT, "Terminal", ret, false);
return ret;
}
bool DesktopFile::icon(char* val, int len) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
if(!Config::get_localized(ENTRY_SECT, "Icon", val, len))
return false;
return true;
}
static bool read_ints(int fd, int* buf, int bufsz, int* int_read) {
E_RETURN_VAL_IF_FAIL(fd != -1, false);
unsigned int bytes, part;
errno = 0;
bytes = part = *int_read = 0;
while(1) {
/* extra safety */
if(bytes >= sizeof(int) * 2)
break;
while(1) {
part = read(fd, (char*)buf + bytes, sizeof(int) * bufsz - bytes);
if(errno != EINTR)
break;
}
if(part > 0) {
bytes += part;
} else if(part == 0) {
break;
} else {
/* bad happened; bail out */
return false;
}
}
*int_read = (int)(bytes / sizeof(int));
return true;
}
static bool bus_property_get(EdbusConnection &con,
const char *service,
const char *path,
const char *iface,
const char *prop,
EdbusMessage *ret)
{
EdbusMessage msg;
msg.create_method_call(service, path, "org.freedesktop.DBus.Properties", "Get");
msg << EdbusData::from_string(iface);
msg << EdbusData::from_string(prop);
E_RETURN_VAL_IF_FAIL(con.send_with_reply_and_block(msg, 1000, *ret), false);
E_RETURN_VAL_IF_FAIL(ret->size() == 1, false);
return true;
}
bool DesktopFile::no_display(void) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
bool ret;
Config::get(ENTRY_SECT, "NoDisplay", ret, false);
return ret;
}
bool DesktopFile::mime_type(char* val, int len) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
if(!Config::get(ENTRY_SECT, "MimeType", val, len))
return false;
return true;
}
bool DesktopFile::startup_notify(void) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
bool ret;
Config::get(ENTRY_SECT, "StartupNotify", ret, false);
return ret;
}
bool dir_writeable(const char* name) {
E_ASSERT(name != NULL);
struct stat s;
E_RETURN_VAL_IF_FAIL(stat(name, &s) == 0, false);
return (access(name, W_OK) == 0) && S_ISDIR(s.st_mode);
}
bool DesktopFile::not_show_in(char* val, int len) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
if(!Config::get(ENTRY_SECT, "NotShowIn", val, len))
return false;
return true;
}
bool Entity::get_prototype_as_scheme(char *buf, int bufsz) {
E_RETURN_VAL_IF_FAIL(name != NULL, false);
E_RETURN_VAL_IF_FAIL(tp != ENTITY_NONE, false);
String ret;
if(tp == ENTITY_SIGNAL) {
ret.printf("(dbus-signal \"%s\" \"%s\" \"%s\"", get_path(), get_interface(), get_name());
if(args.empty()) {
ret += ")";
} else {
String scm_params;
signature_to_scheme(args, scm_params);
if(!scm_params.empty()) {
ret += ' ';
ret += scm_params;
}
ret += ')';
}
} else if(tp == ENTITY_METHOD) {
ret.printf("(dbus-call \"%s\" \"%s\" \"%s\" \"%s\"", get_service(), get_path(), get_interface(), get_name());
if(args.empty())
ret += ")";
else {
String scm_params;
signature_to_scheme(args, scm_params);
if(!scm_params.empty()) {
ret += ' ';
ret += scm_params;
}
ret += ')';
}
} else {
/* property */
ret.printf("(dbus-property-get \"%s\" \"%s\" \"%s\" \"%s\")", get_service(), get_path(), get_interface(), get_name());
}
if(!ret.empty()) {
edelib_strlcpy(buf, ret.c_str(), bufsz);
return true;
}
return false;
}
bool DesktopFile::name(char* val, int len) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
/* TODO: Name key is required too; place it next to Type */
if(!Config::get_localized(ENTRY_SECT, "Name", val, len))
return false;
return true;
}
bool DesktopFile::comment(char* val, int len) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
if(Config::get_localized(ENTRY_SECT, "Comment", val, len))
return true;
return Config::get(ENTRY_SECT, "Comment", val, len);
}
bool ColorDb::find(const char *name, unsigned char &r, unsigned char &g, unsigned char &b) {
E_RETURN_VAL_IF_FAIL(priv != NULL, false);
E_RETURN_VAL_IF_FAIL(priv->list.empty() != true, false);
ColorInfoListIt it = priv->list.begin(), ite = priv->list.end();
for(; it != ite; ++it) {
if((*it).name == name) {
r = (*it).r;
g = (*it).g;
b = (*it).b;
return true;
}
}
return false;
}
EDELIB_NS_BEGIN
bool dir_exists(const char* name) {
E_ASSERT(name != NULL);
struct stat s;
E_RETURN_VAL_IF_FAIL(stat(name, &s) == 0, false);
return (access(name, F_OK) == 0) && S_ISDIR(s.st_mode);
}
bool MessageBox::set_theme_icon(const char* name) {
E_RETURN_VAL_IF_FAIL(IconLoader::inited(), false);
String p = IconLoader::get_path(name, ICON_SIZE_MEDIUM);
if(p.empty())
return false;
return set_icon(p.c_str());
}
bool Theme::get_item(const char *style_name, const char *item_name, long &ret, long fallback) {
E_RETURN_VAL_IF_FAIL(priv->is_loaded == true, false);
E_RETURN_VAL_IF_FAIL(style_name != NULL, false);
E_RETURN_VAL_IF_FAIL(item_name != NULL, false);
scheme *ss = priv->sc;
bool found = false;
pointer style = get_style_once(priv, ss, style_name);
if(style == ss->NIL) {
ret = fallback;
return found;
}
pointer lst, item, val;
while(style != ss->NIL) {
lst = ss->vptr->pair_car(style);
item = ss->vptr->pair_car(lst);
val = ss->vptr->pair_car(ss->vptr->pair_cdr(lst));
/* check if we found matching item */
if(ss->vptr->is_symbol(item) && strcmp(item_name, ss->vptr->symname(item)) == 0) {
#if THEME_EVAL_VALUE_PAIR
if(ss->vptr->is_pair(val))
val = edelib_scheme_eval(ss, val);
#endif
/* if it is not long, simply continue until find item with the long value */
if(ss->vptr->ivalue(val)) {
ret = ss->vptr->ivalue(val);
found = true;
break;
}
}
style = ss->vptr->pair_cdr(style);
}
if(!found)
ret = fallback;
return found;
}
bool DesktopFile::not_show_in(list<String>& lst) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
char buff[256];
if(!Config::get(ENTRY_SECT, "NotShowIn", buff, sizeof(buff)-1))
return false;
stringtok(lst, buff, ";");
return true;
}
bool Desktop::rename_icon(DesktopIcon *di, const char *name) {
di->copy_label(name);
di->update_label_font_and_size();
di->fast_redraw();
/* open file and try to change the name */
DesktopFile df;
E_RETURN_VAL_IF_FAIL(df.load(di->get_path()) == true, false);
df.set_name(name);
return df.save(di->get_path());
}
static const char *get_state_str(EdbusConnection &con, const char *path) {
const char * fallback = _("unknown");
int ret;
E_RETURN_VAL_IF_FAIL(get_state(con, path, &ret), fallback);
switch(ret) {
case UPOWER_STATE_CHARGED: return _("charged");
case UPOWER_STATE_CHARGING: return _("charging");
case UPOWER_STATE_DISCHARGING: return _("discharging");
case UPOWER_STATE_EMPTY: return _("empty");
}
return fallback;
}
bool dir_empty(const char* name) {
E_ASSERT(name != NULL);
DIR *dirp = opendir(name);
E_RETURN_VAL_IF_FAIL(dirp != NULL, false);
errno = 0;
struct dirent *dp = readdir_ignoring_dots(dirp);
int saved_errno = errno;
closedir(dirp);
if(dp != NULL)
return false;
return (saved_errno == 0 ? true : false);
}
bool DesktopFile::try_exec(bool& program_found) {
E_RETURN_VAL_IF_FAIL(errcode == DESK_FILE_SUCCESS, false);
char buf[BUF_SIZE];
if(!Config::get(ENTRY_SECT, "TryExec", buf, BUF_SIZE))
return false;
String exec_path = file_path(buf);
if(exec_path.empty()) {
program_found = false;
return true;
}
program_found = true;
return true;
}
