static dbus_bool_t edbus_add_timeout(DBusTimeout* timeout, void* data) {
E_ASSERT(timeout != NULL);
/* D-Bus interval sees in miliseconds, but FLTK see it in seconds */
int interval = dbus_timeout_get_interval(timeout);
/* E_DEBUG(E_STRLOC ": added timeout to %i ms\n", interval); */
Fl::add_timeout(interval / 1000, timeout_cb, data);
return 1;
}
void String::printf(const char* fmt, ...) {
E_ASSERT(fmt != NULL);
char buf[PRINTF_BUF];
va_list ap;
va_start(ap, fmt);
vsnprintf(buf, PRINTF_BUF, fmt, ap);
va_end(ap);
assign((char*)buf);
}
static void dispatch_cb(void* d) {
EdbusConnImpl* dc = (EdbusConnImpl*)d;
E_ASSERT(dc != NULL);
/* E_DEBUG(E_STRLOC ": dispatch_cb()\n"); */
while(dbus_connection_dispatch(dc->conn) == DBUS_DISPATCH_DATA_REMAINS)
;
Fl::remove_timeout(dispatch_cb);
}
/*
* Create section if not exist, or if exist
* return that one.
*/
ConfigSection* Config::add_section(const char* section) {
E_ASSERT(section != NULL);
ConfigSection* sc = find_section(section);
if (!sc) {
++sectnum;
sc = new ConfigSection(section);
section_list.push_back(sc);
}
return sc;
}
static void rename_cb(Fl_Widget*, void* d) {
DesktopIcon* di = (DesktopIcon*)d;
E_ASSERT(di != NULL);
const char* new_name = edelib::input(_("New name"), di->label());
if(!new_name)
return;
if(new_name[0] == '\0')
return;
di->rename(new_name);
}
/*----------------------------------------------------------------------------*/
evt_T * efRetrieveEvt(
evtQ_T * evtQ) {
evt_T * evt;
E_PORT_DIS_INT();
E_ASSERT(evtQ != NULL);
evt = evtQ->buff[evtQ->tail];
evtQ->tail++;
if (evtQ->tail == evtQ->size) {
evtQ->tail = 0U;
}
evtQ->count--;
E_ASSERT(((int)evtQ->count) > 0U);
E_PORT_ENA_INT();
return (evt);
}
void Desktop::select(DesktopIcon *ic, bool do_redraw) {
E_ASSERT(ic != NULL);
if(in_selection(ic)) return;
selectionbuf.push_back(ic);
if(!ic->is_focused()) {
ic->do_focus();
if(do_redraw) ic->fast_redraw();
}
}
/*----------------------------------------------------------------------------*/
uint8_t efGetAllocated(
evtQ_T * evtQ) {
E_PORT_DIS_INT();
E_ASSERT(evtQ != NULL);
uint8_t all = evtQ->count;
E_PORT_ENA_INT();
return all;
}
String icon_chooser(const char* dir) {
E_ASSERT(dir != NULL);
IconChooser ic;
ic.load(dir);
ic.show();
while(ic.visible())
Fl::wait();
return ic.get_ret();
}
int run_async(const char* fmt, ...) {
E_ASSERT(fmt != NULL);
char buf[CMD_BUF_SIZE];
va_list ap;
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
return fork_child_async(buf, 0);
}
bool Desktop::in_selection(const DesktopIcon* ic) {
E_ASSERT(ic != NULL);
if(selectionbuf.empty())
return false;
for(DesktopIconListIt it = selectionbuf.begin(), ite = selectionbuf.end(); it != ite; ++it) {
if((*it) == ic)
return true;
}
return false;
}
void ConfigSection::remove_entry(const char* key) {
E_ASSERT(key != NULL);
int klen = strlen(key);
unsigned int hh = do_hash(key, klen);
EntryListIter it = entry_list.begin();
for(; it != entry_list.end(); ++it) {
ConfigEntry* e = *it;
if(hh == e->hash && strncmp(e->key, key, e->keylen) == 0)
entry_list.erase(it);
}
}
void XSettingsClient::set(const char* name, const char* val) {
E_ASSERT(client_data != NULL && "init() must be called before this function");
if(!client_data->manager_win)
return;
XSettingsSetting setting;
setting.name = (char*)name;
setting.type = XSETTINGS_TYPE_STRING;
setting.data.v_string = (char*)val;
xsettings_manager_set_setting(client_data, &setting);
}
DesktopIcon::DesktopIcon(GlobalIconSettings* gs, IconSettings* is, int bg) :
Fl_Widget(is->x, is->y, ICON_SIZE_MIN_W, ICON_SIZE_MIN_H) {
E_ASSERT(gs != NULL);
lwidth = lheight = 0;
focus = false;
micon = NULL;
darker_img = NULL;
/*
* GlobalIconSettings is shared from desktop so we only
* reference it. On other hand IconSettings is not shared
* and we must construct a copy from given parameter
*/
globals = gs;
settings = new IconSettings;
settings->name = is->name;
settings->cmd = is->cmd;
settings->icon = is->icon;
settings->icon2 = is->icon2;
settings->type = is->type;
settings->key_name= is->key_name;
settings->full_path = is->full_path;
// x,y are not needed since x(), y() are filled with it
// setting fonts is TODO :P
#if 0
Fl::set_font((Fl_Font)20, "-windows-*-medium-r-*-*-14-*-*-*-*-*-*-*");
labelfont((Fl_Font)20);
#endif
label(settings->name.c_str());
imenu = new Fl_Menu_Button(0, 0, 0, 0);
if(settings->type == ICON_TRASH)
imenu->menu(icon_trash_menu);
else
imenu->menu(icon_menu);
load_icon(ICON_FACE_ONE);
fix_position(x(), y());
//Use desktop color as color for icon background
color(bg);
align(FL_ALIGN_WRAP);
update_label_size();
}
void EdbusConnection::setup_filter(void) {
E_ASSERT(dc != NULL);
E_ASSERT(dc->conn != NULL);
DBusError err;
dbus_error_init(&err);
/* if we didn't registered any signal match, match everything */
if(dc->signal_matches == 0) {
dbus_bus_add_match(dc->conn, "type='signal'", &err);
if(dbus_error_is_set(&err)) {
E_WARNING(E_STRLOC ": Signal match failed: %s, %s\n", err.name, err.message);
dbus_error_free(&err);
return;
}
}
/* if we didn't registered any method match, match everything */
if(dc->method_matches == 0) {
const char* name = unique_name();
if(name) {
char buff[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
snprintf(buff, sizeof(buff), "destination='%s'", name);
dbus_bus_add_match(dc->conn, buff, &err);
if(dbus_error_is_set(&err)) {
E_WARNING(E_STRLOC ": Destination match failed: %s, %s\n", err.name, err.message);
dbus_error_free(&err);
return;
}
} else
E_WARNING(E_STRLOC ": Unable to get unique name\n");
}
dbus_connection_add_filter(dc->conn, edbus_signal_filter, dc, 0);
}
/*----------------------------------------------------------------------------*/
uint8_t efGetFree(
evtQ_T * evtQ) {
uint8_t space;
E_PORT_DIS_INT();
E_ASSERT(evtQ != NULL);
space = (evtQ->size - 1U) - evtQ->count;
E_PORT_ENA_INT();
return (space);
}
void bugzilla_logout(BugzillaData *data) {
E_ASSERT(data != NULL);
xmlrpc_value *result;
xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "User.logout", &result, "()");
if(data->xenv.fault_occurred) {
E_WARNING(E_STRLOC ": Unable to call xmlrpc function (%s)\n", data->xenv.fault_string);
if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
return;
}
xmlrpc_DECREF(result);
}
ConfigEntry* ConfigSection::find_entry(const char* key) {
E_ASSERT(key != NULL);
int klen = strlen(key);
unsigned int hh = do_hash(key, klen);
EntryListIter it = entry_list.begin(), it_end = entry_list.end();
for (; it != it_end; ++it) {
ConfigEntry* e = *it;
if (hh == e->hash && strncmp(e->key, key, e->keylen) == 0)
return e;
}
return NULL;
}
void XSettingsClient::check_manager_window(void) {
E_ASSERT(client_data != NULL);
XGrabServer(client_data->display); // required by spec
client_data->manager_win = XGetSelectionOwner(client_data->display, client_data->selection_atom);
if(client_data->manager_win)
XSelectInput(client_data->display, client_data->manager_win, PropertyChangeMask | StructureNotifyMask);
XUngrabServer(client_data->display); // required by spec
XFlush(client_data->display);
read_settings();
}
/*
* Create section if not exist, or if exist
* return that one.
*/
ConfigSection* Config::add_section(const char* section) {
E_ASSERT(section != NULL);
ConfigSection* sc = find_section(section);
if (!sc) {
#ifdef CONFIG_INTERNAL
printf("---------------> adding section %s\n", section);
#endif
++sectnum;
sc = new ConfigSection(section);
section_list.push_back(sc);
}
return sc;
}
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);
}
static EdbusCallbackItem* scan_callback_table(EdbusCallbackItem* table, unsigned int sz, const EdbusMessage& msg) {
E_ASSERT(table != NULL);
for(unsigned int i = 0; i < sz; i++) {
if((strcmp(table[i].interface, msg.interface()) == 0) && (strcmp(table[i].name, msg.member()) == 0)) {
/* allow NULL in path */
if(!table[i].path)
return &table[i];
/* have path, scan it */
if(strcmp(table[i].path, msg.path()) == 0)
return &table[i];
}
}
return NULL;
}
/*----------------------------------------------------------------------------*/
bool_T efIsEvtQFull(
evtQ_T * evtQ) {
E_PORT_DIS_INT();
E_ASSERT(evtQ != NULL);
if (1U == (evtQ->size - evtQ->count)) {
E_PORT_ENA_INT();
return TRUE;
} else {
E_PORT_ENA_INT();
return FALSE;
}
}
/*----------------------------------------------------------------------------*/
bool_T efIsEvtQEmpty(
evtQ_T * evtQ) {
E_PORT_DIS_INT();
E_ASSERT(evtQ != NULL);
if (0U == evtQ->count) {
E_PORT_ENA_INT();
return TRUE;
} else {
E_PORT_ENA_INT();
return FALSE;
}
}
void XSettingsClient::set(const char* name, unsigned short red, unsigned short green,
unsigned short blue, unsigned short alpha) {
E_ASSERT(client_data != NULL && "init() must be called before this function");
if(!client_data->manager_win)
return;
XSettingsSetting setting;
setting.name = (char*)name;
setting.type = XSETTINGS_TYPE_COLOR;
setting.data.v_color.red = red;
setting.data.v_color.green = green;
setting.data.v_color.blue = blue;
setting.data.v_color.alpha = alpha;
xsettings_manager_set_setting(client_data, &setting);
}
static void to_dbus_iter_from_struct(DBusMessageIter* parent_it, const EdbusData& data) {
E_ASSERT(data.is_struct());
EdbusList s = data.to_struct();
EdbusList::const_iterator it = s.begin(), it_end = s.end();
DBusMessageIter sub;
/* structs does not require signature for types they contains, the same as dicts */
dbus_message_iter_open_container(parent_it, DBUS_TYPE_STRUCT, NULL, &sub);
while(it != it_end) {
to_dbus_iter_from_edbusdata_type(&sub, *it);
++it;
}
dbus_message_iter_close_container(parent_it, &sub);
}
String icon_chooser(IconSizes sz, IconContext ctx) {
IconChooser ic;
if(IconLoader::inited()) {
list<String> all;
const IconTheme* t = IconLoader::theme();
E_ASSERT(t != NULL && "IconLoader loaded, but IconTheme object NULL");
t->query_icons(all, sz, ctx);
ic.load_from_list(all);
}
ic.show();
while(ic.visible())
Fl::wait();
return ic.get_ret();
}
char *bugzilla_get_version(BugzillaData *data) {
E_ASSERT(data != NULL);
xmlrpc_value *result;
xmlrpc_client_call2f(&data->xenv, data->xcli, data->url.c_str(), "Bugzilla.version", &result, "()");
if(data->xenv.fault_occurred) {
E_WARNING(E_STRLOC ": Unable to call xmlrpc function (%s)\n", data->xenv.fault_string);
if(data->cb) (data->cb)(data->xenv.fault_string, data->cb_data);
return (char*)"";
}
/* this value will be malloc()-ated by xmlrpc_decompose_value() and should be freeed by user */
char *ret;
xmlrpc_decompose_value(&data->xenv, result, "{s:s,*}", "version", &ret);
xmlrpc_DECREF(result);
return ret;
}
/*
* Scans throught the section list, and if found
* return it. Otherwise, return NULL.
*/
ConfigSection* Config::find_section(const char* section) {
E_ASSERT(section != NULL);
int slen = strlen(section);
unsigned int hh = do_hash(section, slen);
// check if we have cached section
if (cached && cached->shash == hh && (strncmp(cached->sname, section, cached->snamelen) == 0))
return cached;
SectionListIter it = section_list.begin(), it_end = section_list.end();
for (; it != it_end; ++it) {
ConfigSection *cs = *it;
if (cs->shash == hh && (strncmp(cs->sname, section, cs->snamelen) == 0)) {
cached = cs;
return cs;
}
}
return NULL;
}
static void to_dbus_iter_from_array(DBusMessageIter* parent_it, const EdbusData& data) {
E_ASSERT(data.is_array());
/*
* Marshalling arrays is much simpler than e.g. dict; we already know all elements
* are the same type. The only tricky case is when array elements are another array, dict
* or struct so signature, where build_signature() comes in
*/
EdbusList arr = data.to_array();
/* TODO: allow empty containers ??? */
if(arr.size() < 1)
return;
EdbusList::const_iterator it = arr.begin(), it_end = arr.end();
const char* value_sig;
String ss;
if(arr.value_type_is_container()) {
build_signature(*it, ss);
value_sig = ss.c_str();
} else
value_sig = from_edbusdata_type_to_dbus_type_string(arr.value_type());
/* printf("Array entry signature: %s\n", value_sig); */
/*
* dbus_message_iter_open_container() will by default append container
* signature (at the start of signature array)
*/
DBusMessageIter sub;
dbus_message_iter_open_container(parent_it, DBUS_TYPE_ARRAY, value_sig, &sub);
while(it != it_end) {
to_dbus_iter_from_edbusdata_type(&sub, *it);
++it;
}
dbus_message_iter_close_container(parent_it, &sub);
}
