int
message_popup(const char *message, int flags)
{
prop_t *p;
int rval;
p = prop_create_root(NULL);
prop_set_string(prop_create(p, "type"), "message");
prop_set_string_ex(prop_create(p, "message"), NULL, message,
flags & MESSAGE_POPUP_RICH_TEXT ?
PROP_STR_RICH : PROP_STR_UTF8);
if(flags & MESSAGE_POPUP_CANCEL)
prop_set_int(prop_create(p, "cancel"), 1);
if(flags & MESSAGE_POPUP_OK)
prop_set_int(prop_create(p, "ok"), 1);
event_t *e = popup_display(p);
prop_destroy(p);
if(event_is_action(e, ACTION_OK))
rval = MESSAGE_POPUP_OK;
else if(event_is_action(e, ACTION_CANCEL))
rval = MESSAGE_POPUP_CANCEL;
else
rval = 0;
event_release(e);
return rval;
}
void
mp_become_primary(struct media_pipe *mp)
{
mp_init_audio(mp);
if(media_primary == mp)
return;
hts_mutex_lock(&media_mutex);
assert(mp->mp_flags & MP_PRIMABLE);
if(media_primary != NULL) {
prop_set_int(media_primary->mp_prop_primary, 0);
event_t *e = event_create_action(ACTION_STOP);
mp_enqueue_event(media_primary, e);
event_release(e);
}
media_primary = mp_retain(mp);
prop_select(mp->mp_prop_root);
prop_link(mp->mp_prop_root, media_prop_current);
prop_set_int(mp->mp_prop_primary, 1);
hts_mutex_unlock(&media_mutex);
}
static void
mp_set_clr_flags_locked(media_pipe_t *mp, int set, int clr)
{
mp->mp_flags &= ~clr;
mp->mp_flags |= set;
prop_set_int(mp->mp_prop_canSeek, mp->mp_flags & MP_CAN_SEEK ? 1 : 0);
prop_set_int(mp->mp_prop_canPause, mp->mp_flags & MP_CAN_PAUSE ? 1 : 0);
prop_set_int(mp->mp_prop_canEject, mp->mp_flags & MP_CAN_EJECT ? 1 : 0);
}
int
nav_open_error(prop_t *root, const char *msg)
{
prop_t *model = prop_create(root, "model");
prop_set_string(prop_create(model, "type"), "openerror");
prop_set_int(prop_create(model, "loading"), 0);
prop_set_string(prop_create(model, "error"), msg);
prop_set_int(prop_create(root, "directClose"), 1);
return 0;
}
int
message_popup(const char *message, int flags, const char **extra)
{
prop_t *p;
int rval;
p = prop_ref_inc(prop_create_root(NULL));
TRACE(TRACE_DEBUG, "Notification", "%s", message);
prop_set_string(prop_create(p, "type"), "message");
prop_set_string_ex(prop_create(p, "message"), NULL, message,
flags & MESSAGE_POPUP_RICH_TEXT ?
PROP_STR_RICH : PROP_STR_UTF8);
if(extra) {
int cnt = 1;
prop_t *btns = prop_create(p, "buttons");
while(*extra) {
prop_t *b = prop_create_root(NULL);
prop_set_string(prop_create(b, "title"), *extra);
char action[10];
snprintf(action, sizeof(action), "btn%d", cnt);
prop_set_string(prop_create(b, "action"), action);
if(prop_set_parent(b, btns))
abort();
cnt++;
extra++;
}
}
if(flags & MESSAGE_POPUP_CANCEL)
prop_set_int(prop_create(p, "cancel"), 1);
if(flags & MESSAGE_POPUP_OK)
prop_set_int(prop_create(p, "ok"), 1);
event_t *e = popup_display(p);
prop_destroy(p);
prop_ref_dec(p);
const event_payload_t *ep = (const event_payload_t *)e;
if(event_is_action(e, ACTION_OK))
rval = MESSAGE_POPUP_OK;
else if(event_is_action(e, ACTION_CANCEL))
rval = MESSAGE_POPUP_CANCEL;
else if(event_is_type(e, EVENT_DYNAMIC_ACTION) &&
!strncmp(ep->payload, "btn", 3))
rval = atoi(ep->payload + 3);
else
rval = 0;
event_release(e);
return rval;
}
static JSBool
js_item_addOptAction(JSContext *cx, JSObject *obj,
uintN argc, jsval *argv, jsval *rval)
{
js_item_t *ji = JS_GetPrivate(cx, obj);
const char *title;
const char *action;
if (!JS_ConvertArguments(cx, argc, argv, "ss", &title, &action))
return JS_FALSE;
prop_t *p = prop_create_root(NULL);
prop_set_string(prop_create(p, "type"), "action");
prop_set_string(prop_create(prop_create(p, "metadata"), "title"), title);
prop_set_int(prop_create(p, "enabled"), 1);
prop_set_string(prop_create(p, "action"), action);
prop_t *opts = prop_create_r(ji->ji_root, "options");
if(prop_set_parent(p, opts))
prop_destroy(p);
prop_ref_dec(opts);
*rval = JSVAL_VOID;
return JS_TRUE;
}
setting_t *
settings_create_bool(prop_t *parent, const char *id, prop_t *title,
int initial, htsmsg_t *store,
prop_callback_int_t *cb, void *opaque,
int flags, prop_courier_t *pc,
settings_saver_t *saver, void *saver_opaque)
{
setting_t *s = setting_create_leaf(parent, title, "bool", "value", flags);
prop_sub_t *sub;
s->s_id = strdup(id);
s->s_callback = cb;
s->s_opaque = opaque;
if(store != NULL)
initial = htsmsg_get_u32_or_default(store, id, initial);
prop_set_int(s->s_val, !!initial);
if(flags & SETTINGS_INITIAL_UPDATE)
settings_int_callback(s, !!initial);
sub = prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE,
PROP_TAG_CALLBACK_INT, settings_int_callback, s,
PROP_TAG_ROOT, s->s_val,
PROP_TAG_COURIER, pc,
NULL);
s->s_sub = sub;
s->s_store = store;
s->s_saver = saver;
s->s_saver_opaque = saver_opaque;
return s;
}
void
audio_mastervol_init(void)
{
htsmsg_t *m = htsmsg_store_load("audiomixer");
int32_t i32;
prop_t *prop_audio;
prop_audio = prop_create(prop_get_global(), "audio");
prop_mastervol = prop_create(prop_audio, "mastervolume");
prop_mastermute = prop_create(prop_audio, "mastermute");
prop_set_float_clipping_range(prop_mastervol, -75, 0);
prop_set_int(prop_mastermute, 0);
if(m != NULL && !htsmsg_get_s32(m, "master-volume", &i32))
prop_set_float(prop_mastervol, (float)i32 / 1000);
htsmsg_destroy(m);
prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE,
PROP_TAG_CALLBACK_FLOAT, save_matervol, NULL,
PROP_TAG_ROOT, prop_mastervol,
NULL);
}
static navigator_t *
nav_create(prop_t *prop)
{
navigator_t *nav = calloc(1, sizeof(navigator_t));
nav->nav_prop_root = prop;
TAILQ_INIT(&nav->nav_pages);
TAILQ_INIT(&nav->nav_history);
nav->nav_prop_pages = prop_create(nav->nav_prop_root, "pages");
nav->nav_prop_curpage = prop_create(nav->nav_prop_root, "currentpage");
nav->nav_prop_can_go_back = prop_create(nav->nav_prop_root, "canGoBack");
nav->nav_prop_can_go_fwd = prop_create(nav->nav_prop_root, "canGoForward");
nav->nav_prop_can_go_home = prop_create(nav->nav_prop_root, "canGoHome");
prop_set_int(nav->nav_prop_can_go_home, 1);
nav->nav_pc = prop_courier_create_thread(NULL, "navigator");
nav->nav_eventsink =
prop_subscribe(0,
PROP_TAG_NAME("nav", "eventsink"),
PROP_TAG_CALLBACK, nav_eventsink, nav,
PROP_TAG_COURIER, nav->nav_pc,
PROP_TAG_ROOT, nav->nav_prop_root,
NULL);
nav->nav_dtor_tracker =
prop_subscribe(PROP_SUB_TRACK_DESTROY,
PROP_TAG_CALLBACK, nav_dtor_tracker, nav,
PROP_TAG_COURIER, nav->nav_pc,
PROP_TAG_ROOT, nav->nav_prop_root,
NULL);
return nav;
}
void
darwin_init_cpu_monitor(void)
{
kern_return_t r;
processor_info_t pinfo;
mach_msg_type_number_t msg_count;
p_sys = prop_create(prop_get_global(), "system");
r = host_processor_info(mach_host_self (),
PROCESSOR_CPU_LOAD_INFO,
&cpu_count,
(processor_info_array_t *)&pinfo,
&msg_count);
if(r != KERN_SUCCESS) {
TRACE(TRACE_ERROR, "darwin",
"host_processor_info(PROCESSOR_CPU_LOAD_INFO) failed %d", r);
return;
}
p_cpu = calloc(cpu_count, sizeof(prop_t *));
p_load = calloc(cpu_count, sizeof(prop_t *));
last_total = calloc(cpu_count, sizeof(unsigned int));
last_idle = calloc(cpu_count, sizeof(unsigned int));
prop_set_int(prop_create(prop_create(p_sys, "cpuinfo"), "available"), 1);
p_cpuroot = prop_create(prop_create(p_sys, "cpuinfo"), "cpus");
vm_deallocate(mach_task_self(),
(vm_address_t)pinfo,
(vm_size_t)sizeof(*pinfo) * msg_count);
cpu_monitor_do();
callout_arm(&timer, timercb, NULL, 1);
}
static void
audio_mastervol_init(void)
{
htsmsg_t *m = htsmsg_store_load("audiomixer");
int32_t i32;
prop_t *pa, *mv, *mm;
pa = prop_create(prop_get_global(), "audio");
mv = prop_create(pa, "mastervolume");
mm = prop_create(pa, "mastermute");
prop_set_float_clipping_range(mv, -75, 12);
if(m != NULL && !htsmsg_get_s32(m, "master-volume", &i32))
prop_set_float(mv, (float)i32 / 1000);
prop_set_int(mm, 0);
htsmsg_release(m);
prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE,
PROP_TAG_CALLBACK_FLOAT, save_matervol, NULL,
PROP_TAG_ROOT, mv,
NULL);
prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE,
PROP_TAG_SET_INT, &audio_master_mute,
PROP_TAG_ROOT, mm,
NULL);
}
void
bookmarks_init(void)
{
htsmsg_field_t *f;
htsmsg_t *m, *n, *o;
hts_mutex_init(&bookmark_mutex);
bookmarks = prop_create(settings_add_dir(NULL, "Bookmarks", "bookmark", NULL),
"model");
prop_set_int(prop_create(bookmarks, "mayadd"), 1);
prop_subscribe(0,
PROP_TAG_CALLBACK, bookmarks_callback, NULL,
PROP_TAG_ROOT, prop_create(bookmarks, "nodes"),
PROP_TAG_MUTEX, &bookmark_mutex,
NULL);
if((m = htsmsg_store_load("bookmarks")) != NULL) {
n = htsmsg_get_map(m, "nodes");
HTSMSG_FOREACH(f, n) {
if((o = htsmsg_get_map_by_field(f)) == NULL)
continue;
bookmark_load(o);
}
htsmsg_destroy(m);
}
int
search_class_create(prop_t *parent, prop_t **nodesp, prop_t **entriesp,
const char *title, const char *icon)
{
prop_t *p = prop_create_root(NULL);
prop_t *m = prop_create(p, "metadata");
prop_t *n, *e;
char url[URL_MAX];
backend_prop_make(p, url, sizeof(url));
prop_set_string(prop_create(p, "url"), url);
prop_set_string(prop_create(m, "title"), title);
if(icon != NULL)
prop_set_string(prop_create(m, "icon"), icon);
prop_set_string(prop_create(p, "type"), "directory");
n = prop_create(p, "nodes");
e = prop_create(p, "entries");
prop_set_int(e, 0);
*nodesp = prop_ref_inc(n);
*entriesp = prop_ref_inc(e);
if(prop_set_parent(p, parent)) {
prop_destroy(p);
return 1;
}
return 0;
}
static void
update_abitrate(media_pipe_t *mp, media_queue_t *mq,
int size, audio_decoder_t *ad)
{
int i;
int64_t sum;
ad->ad_frame_size[ad->ad_frame_size_ptr] = size;
ad->ad_frame_size_ptr = (ad->ad_frame_size_ptr + 1) & AD_FRAME_SIZE_MASK;
int d = ad->ad_estimated_duration;
if(d == 0) {
ad->ad_last_pts = ad->ad_saved_pts;
ad->ad_saved_pts = ad->ad_pts;
if(ad->ad_pts != PTS_UNSET && ad->ad_last_pts != PTS_UNSET) {
int64_t d64 = ad->ad_pts - ad->ad_last_pts;
if(d64 > 100 && d64 < 500000)
d = d64;
}
}
if(d == 0 || (ad->ad_frame_size_ptr & 7) != 0)
return;
sum = 0;
for(i = 0; i < AD_FRAME_SIZE_LEN; i++)
sum += ad->ad_frame_size[i];
sum = 8000000LL * sum / AD_FRAME_SIZE_LEN / d;
prop_set_int(mq->mq_prop_bitrate, sum / 1000);
}
static void
mip_set(metadb_item_prop_t *mip, const metadb_item_info_t *mii)
{
prop_set_int_ex(mip->mip_playcount, mip->mip_playcount_sub,
mii->mii_playcount);
prop_set_int(mip->mip_lastplayed, mii->mii_lastplayed);
prop_set_float(mip->mip_restartpos, mii->mii_restartpos / 1000.0);
}
int
nav_open_errorf(prop_t *root, const char *fmt, ...)
{
va_list ap;
char buf[200];
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
prop_t *src = prop_create(root, "model");
prop_set_string(prop_create(src, "type"), "openerror");
prop_set_int(prop_create(src, "loading"), 0);
prop_set_string(prop_create(src, "error"), buf);
prop_set_int(prop_create(root, "directClose"), 1);
return 0;
}
setting_t *
settings_create_int(prop_t *parent, const char *id, prop_t *title,
int initial, htsmsg_t *store,
int min, int max, int step,
prop_callback_int_t *cb, void *opaque,
int flags, const char *unit,
prop_courier_t *pc,
settings_saver_t *saver, void *saver_opaque)
{
setting_t *s = setting_create_leaf(parent, title, "integer", "value", flags);
prop_sub_t *sub;
s->s_id = strdup(id);
s->s_callback = cb;
s->s_opaque = opaque;
if(store != NULL)
initial = htsmsg_get_s32_or_default(store, id, initial);
prop_set_int_clipping_range(s->s_val, min, max);
prop_set_int(prop_create(s->s_root, "min"), min);
prop_set_int(prop_create(s->s_root, "max"), max);
prop_set_int(prop_create(s->s_root, "step"), step);
prop_set_string(prop_create(s->s_root, "unit"), unit);
prop_set_int(s->s_val, initial);
s->s_min = min;
s->s_max = max;
if(flags & SETTINGS_INITIAL_UPDATE)
settings_int_callback(s, initial);
sub = prop_subscribe(PROP_SUB_NO_INITIAL_UPDATE,
PROP_TAG_CALLBACK_INT, settings_int_callback, s,
PROP_TAG_ROOT, s->s_val,
PROP_TAG_COURIER, pc,
NULL);
s->s_sub = sub;
s->s_store = store;
s->s_saver = saver;
s->s_saver_opaque = saver_opaque;
return s;
}
static int
glw_ps3_start(ui_t *ui, prop_t *root, int argc, char *argv[], int primary)
{
glw_ps3_t *gp = calloc(1, sizeof(glw_ps3_t));
char confname[PATH_MAX];
const char *theme_path = SHOWTIME_GLW_DEFAULT_THEME_URL;
const char *displayname_title = NULL;
gp->gr.gr_uii.uii_prop = root;
prop_set_int(prop_create(root, "fullscreen"), 1);
snprintf(confname, sizeof(confname), "glw/ps3");
/* Parse options */
argv++;
argc--;
while(argc > 0) {
if(!strcmp(argv[0], "--theme") && argc > 1) {
theme_path = argv[1];
argc -= 2; argv += 2;
continue;
} else {
break;
}
}
if(glw_ps3_init(gp))
return 1;
glw_root_t *gr = &gp->gr;
if(gp->res.height >= 1080) {
gr->gr_base_underscan_h = 66;
gr->gr_base_underscan_v = 34;
} else if(gp->res.height >= 720) {
gr->gr_base_underscan_h = 43;
gr->gr_base_underscan_v = 22;
} else {
gr->gr_base_underscan_h = 36;
gr->gr_base_underscan_v = 20;
}
if(glw_init(gr, theme_path, ui, primary, confname, displayname_title))
return 1;
TRACE(TRACE_INFO, "GLW", "loading universe");
glw_load_universe(gr);
glw_ps3_mainloop(gp);
glw_unload_universe(gr);
glw_reap(gr);
glw_reap(gr);
return 0;
}
void
js_prop_set_from_jsval(JSContext *cx, prop_t *p, jsval value)
{
JSBool b;
if(JSVAL_IS_INT(value)) {
prop_set_int(p, JSVAL_TO_INT(value));
} else if(JSVAL_IS_BOOLEAN(value)) {
prop_set_int(p, JSVAL_TO_BOOLEAN(value));
} else if(JSVAL_IS_NULL(value) || JSVAL_IS_VOID(value)) {
prop_set_void(p);
} else if(JSVAL_IS_DOUBLE(value)) {
double d;
if(JS_ValueToNumber(cx, value, &d))
prop_set_float(p, d);
} else if(JS_HasInstance(cx, RichText, value, &b) && b) {
JSObject *o = JSVAL_TO_OBJECT(value);
jsval v2;
if(!JS_EnterLocalRootScope(cx))
return;
if(!JS_GetProperty(cx, o, "text", &v2)) {
JS_LeaveLocalRootScope(cx);
return;
}
prop_set_string_ex(p, NULL, JS_GetStringBytes(JS_ValueToString(cx, v2)),
PROP_STR_RICH);
JS_LeaveLocalRootScope(cx);
} else if(JSVAL_IS_STRING(value)) {
js_prop_from_str(cx, p, value);
} else if(JSVAL_IS_OBJECT(value)) {
JSObject *obj = JSVAL_TO_OBJECT(value);
JSClass *c = JS_GetClass(cx, obj);
if(!strcmp(c->name, "XML")) // Treat some classes special
js_prop_from_str(cx, p, value);
else
js_prop_from_object(cx, obj, p);
} else {
prop_set_void(p);
}
}
static void
glw_change_underscan_v(void *opaque, int v)
{
glw_root_t *gr = opaque;
v += gr->gr_base_underscan_v;
v = GLW_CLAMP(v, 0, 100);
prop_set_int(gr->gr_prop_underscan_v, v);
gr->gr_underscan_v = v;
}
int
text_dialog_kbrd(const char *message, char** answer, int flags)
{
htsmsg_t *m;
rstr_t *r;
prop_t *p = prop_create_root(NULL);
prop_set_string(prop_create(p, "type"), "textDialogKbrd");
prop_set_string_ex(prop_create(p, "message"), NULL, message,
flags & MESSAGE_POPUP_RICH_TEXT ?
PROP_STR_RICH : PROP_STR_UTF8);
prop_t *string = prop_create(p, "input");
if(flags & MESSAGE_POPUP_CANCEL)
prop_set_int(prop_create(p, "cancel"), 1);
if(flags & MESSAGE_POPUP_OK)
prop_set_int(prop_create(p, "ok"), 1);
event_t *e = popup_display_kbrd(p, string);
if (event_is_action(e, ACTION_OK))
{
m = htsmsg_create_map();
r = prop_get_string(string);
htsmsg_add_str(m, "input", r ? rstr_get(r) : "");
rstr_release(r);
htsmsg_get_str(m, "input");
setstr(answer, m, "input");
}
prop_destroy(p);
if(event_is_action(e, ACTION_CANCEL)){
event_release(e);
return -1;
}
event_release(e);
return 0;
}
static prop_t *
setting_add(prop_t *parent, prop_t *title, const char *type, int flags)
{
prop_t *p = setting_get(parent, flags);
if(title != NULL)
set_title2(p, title);
prop_set_string(prop_create(p, "type"), type);
prop_set_int(prop_create(p, "enabled"), 1);
return p;
}
static JSBool
js_appendItem0(JSContext *cx, js_model_t *model, prop_t *parent,
const char *url, const char *type, JSObject *metaobj,
jsval *data, jsval *rval, int enabled,
const char *metabind)
{
prop_t *item = prop_create_root(NULL);
if(url != NULL)
prop_set_string(prop_create(item, "url"), url);
if(data != NULL)
js_prop_set_from_jsval(cx, prop_create(item, "data"), *data);
*rval = JSVAL_VOID;
if(metabind != NULL)
metadb_bind_url_to_prop(NULL, metabind, item);
if(type != NULL) {
prop_set_string(prop_create(item, "type"), type);
if(metaobj)
js_prop_from_object(cx, metaobj, prop_create(item, "metadata"));
} else if(url != NULL) {
if(backend_resolve_item(url, item)) {
prop_destroy(item);
return JS_TRUE;
}
}
prop_set_int(prop_create(item, "enabled"), enabled);
prop_t *p = prop_ref_inc(item);
if(prop_set_parent(item, parent)) {
prop_destroy(item);
prop_ref_dec(p);
} else {
JSObject *robj =
JS_NewObjectWithGivenProto(cx, &item_class,
JSVAL_TO_OBJECT(model->jm_item_proto), NULL);
*rval = OBJECT_TO_JSVAL(robj);
js_item_t *ji = calloc(1, sizeof(js_item_t));
ji->ji_model = model;
ji->ji_root = p;
LIST_INSERT_HEAD(&model->jm_items, ji, ji_link);
JS_SetPrivate(cx, robj, ji);
ji->ji_enable_set_property = 1;
}
return JS_TRUE;
}
static void
glw_change_size(void *opaque, int v)
{
glw_root_t *gr = opaque;
v += gr->gr_base_size;
v = GLW_CLAMP(v, 14, 40);
prop_set_int(gr->gr_prop_size, v);
TRACE(TRACE_DEBUG, "GLW", "UI size scale changed to %d", v);
glw_font_change_size(gr, v);
}
void
prop_set_from_gvariant(GVariant *v, prop_t *p)
{
const GVariantType *T = g_variant_get_type(v);
if(g_variant_type_equal(T, G_VARIANT_TYPE_BOOLEAN)) {
prop_set_int(p, g_variant_get_boolean(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_BYTE)) {
prop_set_int(p, g_variant_get_byte(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT16)) {
prop_set_int(p, g_variant_get_int16(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT16)) {
prop_set_int(p, g_variant_get_uint16(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT32)) {
prop_set_int(p, g_variant_get_int32(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT32)) {
prop_set_int(p, g_variant_get_uint32(v));
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_INT64)) {
int64_t val = g_variant_get_int64(v);
if(val <= INT_MAX)
prop_set_int(p, val);
else
prop_set_float(p, val);
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_UINT64)) {
uint64_t val = g_variant_get_uint64(v);
if(val <= INT_MAX)
prop_set_int(p, val);
else
prop_set_float(p, val);
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_STRING) ||
g_variant_type_equal(T, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_type_equal(T, G_VARIANT_TYPE_SIGNATURE)) {
const gchar *val = g_variant_get_string(v, NULL);
prop_set_string(p, val);
} else if(g_variant_type_equal(T, G_VARIANT_TYPE_VARDICT)) {
prop_void_childs(p);
prop_set_from_vardict(v, p);
} else if(g_variant_type_is_array(T)) {
int num = g_variant_n_children(v);
prop_destroy_childs(p);
for(int i = 0; i < num; i++) {
prop_set_from_gvariant(g_variant_get_child_value(v, i),
prop_create(p, NULL));
}
} else {
fprintf(stderr,
"%s(): can't deal with type %s\n",
__FUNCTION__, g_variant_get_type_string(v));
}
}
static JSBool
js_setLoading(JSContext *cx, JSObject *obj, jsval idval, jsval *vp)
{
js_model_t *jm = JS_GetPrivate(cx, obj);
JSBool on;
if(!JS_ValueToBoolean(cx, *vp, &on))
return JS_FALSE;
prop_set_int(jm->jm_loading, on);
return JS_TRUE;
}
static void
htsp_channelAddUpdate(htsp_connection_t *hc, htsmsg_t *m, int create)
{
uint32_t id, next;
int chnum;
char txt[200];
const char *title, *icon;
htsp_channel_t *ch;
if(htsmsg_get_u32(m, "channelId", &id))
return;
title = htsmsg_get_str(m, "channelName");
icon = htsmsg_get_str(m, "channelIcon");
chnum = htsmsg_get_s32_or_default(m, "channelNumber", -1);
snprintf(txt, sizeof(txt), "%d", id);
hts_mutex_lock(&hc->hc_meta_mutex);
if(create) {
ch = htsp_channel_get(hc, id, 1);
if(prop_set_parent(ch->ch_root, hc->hc_channels_nodes))
abort();
} else {
ch = htsp_channel_get(hc, id, 0);
if(ch == NULL) {
TRACE(TRACE_ERROR, "HTSP", "Got update for unknown channel %d", id);
hts_mutex_unlock(&hc->hc_meta_mutex);
return;
}
}
hts_mutex_unlock(&hc->hc_meta_mutex);
if(icon != NULL)
prop_set_string(ch->ch_prop_icon, icon);
if(title != NULL) {
mystrset(&ch->ch_title, title);
prop_set_string(ch->ch_prop_title, title);
}
if(chnum != -1)
prop_set_int(ch->ch_prop_channelNumber, chnum);
if(htsmsg_get_u32(m, "eventId", &id))
id = 0;
if(htsmsg_get_u32(m, "nextEventId", &next))
next = 0;
update_events(hc, ch->ch_prop_events, id, next);
}
static int
meminfo_do(void)
{
int ret = 0;
char data[1000];
uint64_t v1;
char s1[64];
FILE *f;
prop_t *mem = prop_create(p_sys, "mem");
struct mallinfo mi = mallinfo();
prop_set_int(prop_create(mem, "arena"), (mi.hblks + mi.arena) / 1024);
prop_set_int(prop_create(mem, "unusedChunks"), mi.ordblks);
prop_set_int(prop_create(mem, "activeMem"), mi.uordblks / 1024);
prop_set_int(prop_create(mem, "inactiveMem"), mi.fordblks / 1024);
f = fopen("/proc/meminfo", "r");
if(f == NULL)
return 0;
while(fgets(data, sizeof(data), f) != NULL) {
if(sscanf(data, "%60s %"PRId64, s1, &v1) != 2)
continue;
if(!strcmp(s1, "MemTotal:"))
prop_set_int(prop_create(mem, "systotal"), v1);
else if(!strcmp(s1, "MemFree:"))
prop_set_int(prop_create(mem, "sysfree"), v1);
}
fclose(f);
return ret;
}
static void
update_sleeptimer(void *opaque, int v)
{
TRACE(TRACE_DEBUG, "runcontrol", "Sleep timer %s",
v ? "enabled" : "disabled");
sleeptimer_enabled = v;
if(v) {
prop_set_int(sleeptime_prop, 60);
callout_arm(&sleep_timer, decrease_sleeptimer, NULL, 60);
} else {
callout_disarm(&sleep_timer);
}
}
int
text_dialog(const char *message, char **answer, int flags)
{
rstr_t *r;
*answer = NULL;
prop_t *p = prop_ref_inc(prop_create_root(NULL));
prop_set_string(prop_create(p, "type"), "textDialog");
prop_set_string_ex(prop_create(p, "message"), NULL, message,
flags & MESSAGE_POPUP_RICH_TEXT ?
PROP_STR_RICH : PROP_STR_UTF8);
prop_t *string = prop_create(p, "input");
if(flags & MESSAGE_POPUP_CANCEL)
prop_set_int(prop_create(p, "cancel"), 1);
if(flags & MESSAGE_POPUP_OK)
prop_set_int(prop_create(p, "ok"), 1);
event_t *e = popup_display(p);
if(event_is_action(e, ACTION_OK)) {
r = prop_get_string(string, NULL);
if(r)
*answer = strdup(rstr_get(r));
rstr_release(r);
}
prop_destroy(p);
prop_ref_dec(p);
if(event_is_action(e, ACTION_CANCEL)) {
event_release(e);
return -1;
}
event_release(e);
return 0;
}
