static void
set_source(glw_t *w, rstr_t *filename)
{
glw_image_t *gi = (glw_image_t *)w;
const rstr_t *curname;
if(gi->gi_pending_url != NULL)
curname = gi->gi_pending_url;
else if(gi->gi_pending != NULL)
curname = gi->gi_pending->glt_url;
else if(gi->gi_current != NULL)
curname = gi->gi_current->glt_url;
else
curname = NULL;
if(curname != NULL && filename != NULL && !strcmp(rstr_get(filename),
rstr_get(curname)))
return;
if(gi->gi_pending_url != NULL)
rstr_release(gi->gi_pending_url);
gi->gi_pending_url = filename ? rstr_dup(filename) : rstr_alloc("");
}
static int
hc_prop(http_connection_t *hc, const char *remain, void *opaque,
http_cmd_t method)
{
htsbuf_queue_t out;
rstr_t *r;
int rval, i;
prop_t *p;
const char *action = http_arg_get_req(hc, "action");
if(remain == NULL)
return 404;
p = prop_from_path(remain);
if(p == NULL)
return 404;
htsbuf_queue_init(&out, 0);
switch(method) {
case HTTP_CMD_GET:
if(action != NULL) {
event_t *e = event_create_action_str(action);
prop_send_ext_event(p, e);
event_release(e);
rval = HTTP_STATUS_OK;
break;
}
r = prop_get_string(p, NULL);
if(r == NULL) {
char **childs = prop_get_name_of_childs(p);
if(childs == NULL) {
rval = HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE;
break;
}
for(i = 0; childs[i] != NULL; i++) {
htsbuf_qprintf(&out, "\t%s\n", childs[i]);
}
} else {
htsbuf_append(&out, rstr_get(r), strlen(rstr_get(r)));
htsbuf_append(&out, "\n", 1);
rstr_release(r);
}
rval = http_send_reply(hc, 0, "text/ascii", NULL, NULL, 0, &out);
break;
default:
rval = HTTP_STATUS_METHOD_NOT_ALLOWED;
break;
}
prop_ref_dec(p);
return rval;
}
static void
callback_opt(void *opaque, prop_event_t event, ...)
{
setting_t *s = opaque;
prop_callback_string_t *cb;
prop_t *c;
rstr_t *name;
va_list ap;
va_start(ap, event);
cb = s->s_callback;
if(event != PROP_SELECT_CHILD)
return;
c = va_arg(ap, prop_t *);
name = c ? prop_get_name(c) : NULL;
va_end(ap);
if(cb != NULL)
cb(s->s_opaque, rstr_get(name));
if(s->s_store != NULL && s->s_saver != NULL) {
htsmsg_delete_field(s->s_store, s->s_id);
if(name != NULL)
htsmsg_add_str(s->s_store, s->s_id, rstr_get(name));
s->s_saver(s->s_saver_opaque, s->s_store);
}
rstr_release(name);
}
/**
* Load a view file and do lexographical parsing
*
* Returns pointer to last token, or NULL if an error occured.
* If an error occured 'ei' will be filled with data
*/
token_t *
glw_view_load1(glw_root_t *gr, rstr_t *url, errorinfo_t *ei, token_t *prev,
int may_unlock)
{
token_t *last;
char errbuf[256];
rstr_t *p = fa_absolute_path(url, prev->file);
if(may_unlock)
glw_unlock(gr);
buf_t *b = fa_load(rstr_get(p),
FA_LOAD_VPATHS(gr->gr_vpaths),
FA_LOAD_ERRBUF(errbuf, sizeof(errbuf)),
NULL);
if(may_unlock)
glw_lock(gr);
if(b == NULL) {
snprintf(ei->error, sizeof(ei->error), "Unable to open \"%s\" -- %s",
rstr_get(p), errbuf);
snprintf(ei->file, sizeof(ei->file), "%s", rstr_get(prev->file));
ei->line = prev->line;
rstr_release(p);
return NULL;
}
last = glw_view_lexer(gr, buf_cstr(b), ei, p, prev);
buf_release(b);
rstr_release(p);
return last;
}
int
glw_view_seterr(errorinfo_t *ei, token_t *b, const char *fmt, ...)
{
char buf[PATH_MAX];
va_list ap;
va_start(ap, fmt);
assert(b != NULL);
if(ei == NULL) {
#ifdef GLW_VIEW_ERRORINFO
snprintf(buf, sizeof(buf), "GLW: %s:%d", rstr_get(b->file), b->line);
#else
snprintf(buf, sizeof(buf), "GLW: file?:##");
#endif
tracev(TRACE_NO_PROP, TRACE_ERROR, buf, fmt, ap);
return -1;
}
vsnprintf(ei->error, sizeof(ei->error), fmt, ap);
va_end(ap);
#ifdef GLW_VIEW_ERRORINFO
snprintf(ei->file, sizeof(ei->file), "%s", rstr_get(b->file));
ei->line = b->line;
#else
snprintf(ei->file, sizeof(ei->file), "file?");
#endif
return -1;
}
rstr_t *
rstr_spn(rstr_t *s, const char *set, int offset)
{
size_t len = strlen(rstr_get(s));
if(offset >= len)
return rstr_dup(s);
size_t l = strcspn(rstr_get(s) + offset, set) + offset;
if(l == len)
return rstr_dup(s);
return rstr_allocl(rstr_get(s), l);
}
void *
notify_add(prop_t *root, notify_type_t type, const char *icon, int delay,
rstr_t *fmt, ...)
{
char msg[256];
prop_t *p;
const char *typestr;
int tl;
va_list ap, apx;
switch(type) {
case NOTIFY_INFO: typestr = "info"; tl = TRACE_INFO; break;
case NOTIFY_WARNING: typestr = "warning"; tl = TRACE_INFO; break;
case NOTIFY_ERROR: typestr = "error"; tl = TRACE_ERROR; break;
default: return NULL;
}
va_start(ap, fmt);
va_copy(apx, ap);
tracev(0, tl, "notify", rstr_get(fmt), ap);
vsnprintf(msg, sizeof(msg), rstr_get(fmt), apx);
va_end(ap);
va_end(apx);
rstr_release(fmt);
p = prop_create_root(NULL);
prop_set_string(prop_create(p, "text"), msg);
prop_set_string(prop_create(p, "type"), typestr);
if(icon != NULL)
prop_set_string(prop_create(p, "icon"), icon);
p = prop_ref_inc(p);
if(prop_set_parent(p, root ?: notify_prop_entries))
prop_destroy(p);
if(delay != 0) {
prop_t *r = NULL;
if(delay < 0) {
r = prop_ref_inc(p);
delay = -delay;
}
callout_arm(NULL, notify_timeout, p, delay);
return r;
}
return p;
}
static nls_string_t *
nls_string_find(const char *key)
{
nls_string_t *ns;
unsigned int hash = mystrhash(key) % NLS_STRING_HASH_WIDTH;
hts_mutex_lock(&nls_mutex);
LIST_FOREACH(ns, &nls_strings[hash], ns_link)
if(!strcmp(rstr_get(ns->ns_key), key))
break;
if(ns == NULL) {
ns = calloc(1, sizeof(nls_string_t));
ns->ns_key = rstr_alloc(key);
ns->ns_prop = prop_create_root(NULL);
prop_set_rstring(ns->ns_prop, ns->ns_key);
} else {
LIST_REMOVE(ns, ns_link);
}
LIST_INSERT_HEAD(&nls_strings[hash], ns, ns_link);
hts_mutex_unlock(&nls_mutex);
return ns;
}
static int
set_source(glw_view_eval_context_t *ec, const token_attrib_t *a,
struct token *t)
{
glw_t *w = ec->w;
switch(t->type) {
case TOKEN_VOID:
if(w->glw_class->gc_set_source != NULL)
w->glw_class->gc_set_source(w, NULL);
break;
case TOKEN_CSTRING:
if(w->glw_class->gc_set_source != NULL)
w->glw_class->gc_set_source(w, t->t_cstring);
break;
case TOKEN_RSTRING:
case TOKEN_LINK:
if(w->glw_class->gc_set_source != NULL)
w->glw_class->gc_set_source(w, rstr_get(t->t_rstring));
break;
default:
return glw_view_seterr(ec->ei, t,
"Attribute '%s' expects a string or scalar not %s",
a->name, token2name(t));
}
return 0;
}
static void
glw_quad_render(glw_t *w, const glw_rctx_t *rc)
{
glw_quad_t *q = (glw_quad_t *)w;
if(q->recompile) {
glw_destroy_program(w->glw_root, q->prog);
q->prog = glw_make_program(w->glw_root, NULL, rstr_get(q->fs));
q->recompile = 0;
}
if(!glw_renderer_initialized(&q->r)) {
glw_renderer_init_quad(&q->r);
glw_renderer_vtx_pos(&q->r, 0, -1, -1, 0);
glw_renderer_vtx_pos(&q->r, 1, 1, -1, 0);
glw_renderer_vtx_pos(&q->r, 2, 1, 1, 0);
glw_renderer_vtx_pos(&q->r, 3, -1, 1, 0);
}
glw_renderer_draw(&q->r, w->glw_root, rc,
NULL,
&q->color, NULL, rc->rc_alpha * w->glw_alpha, 0,
q->prog);
}
static int
is_plugin_blacklisted(const char *id, const char *version, rstr_t **reason)
{
char tmp[512];
int verint = parse_version_int(version);
if(!strcmp(id, "custombg")) {
if(reason != NULL) {
*reason =
_("Custom backgrounds can now be set in Settings -> Look and Feel");
}
return 1;
}
for(int i = 0; i < ARRAYSIZE(blacklist); i++) {
if(strcmp(id, blacklist[i].id))
continue;
if(verint >= blacklist[i].version)
continue;
if(reason != NULL) {
rstr_t *f = _("Version %s is no longer compatible with Movian");
snprintf(tmp, sizeof(tmp), rstr_get(f), version);
rstr_release(f);
*reason = rstr_alloc(tmp);
}
return 1;
}
return 0;
}
static int
be_prop_open(prop_t *page, const char *url)
{
proppage_t *pp;
openpage_t *op;
hts_mutex_lock(&pp_mutex);
LIST_FOREACH(pp, &proppages, pp_link)
if(!strcmp(rstr_get(pp->pp_url), url))
break;
if(pp == NULL) {
hts_mutex_unlock(&pp_mutex);
return 1;
}
op = calloc(1, sizeof(openpage_t));
LIST_INSERT_HEAD(&pp->pp_pages, op, op_link);
op->op_pp = pp;
op->op_root = prop_ref_inc(page);
op->op_page_sub =
prop_subscribe(PROP_SUB_TRACK_DESTROY,
PROP_TAG_CALLBACK, op_cb, op,
PROP_TAG_MUTEX, &pp_mutex,
PROP_TAG_ROOT, page,
NULL);
prop_link(pp->pp_model, prop_create(page, "model"));
hts_mutex_unlock(&pp_mutex);
return 0;
}
static const char *
get_identity(glw_t *w)
{
glw_image_t *gi = (glw_image_t *)w;
glw_loadable_texture_t *glt = gi->gi_current;
return glt ? rstr_get(glt->glt_url) : "unloaded";
}
static int
set_page(glw_view_eval_context_t *ec, const token_attrib_t *a,
struct token *t)
{
const char *str;
switch(t->type) {
default:
glw_set(ec->w, GLW_ATTRIB_PAGE_BY_ID, NULL, NULL);
break;
case TOKEN_CSTRING:
glw_set(ec->w, GLW_ATTRIB_PAGE_BY_ID, t->t_cstring, NULL);
break;
case TOKEN_RSTRING:
case TOKEN_LINK:
str = rstr_get(t->t_rstring);
glw_set(ec->w, GLW_ATTRIB_PAGE_BY_ID, str, NULL);
break;
case TOKEN_INT:
glw_set(ec->w, GLW_ATTRIB_PAGE, t->t_int, NULL);
break;
case TOKEN_FLOAT:
glw_set(ec->w, GLW_ATTRIB_PAGE, (int)t->t_float, NULL);
break;
}
return 0;
}
static void
news_sink(void *opaque, prop_event_t event, ...)
{
prop_t *p = opaque;
event_t *e;
va_list ap;
va_start(ap, event);
switch(event) {
case PROP_DESTROYED:
prop_unsubscribe(va_arg(ap, prop_sub_t *));
prop_ref_dec(p);
break;
case PROP_EXT_EVENT:
e = va_arg(ap, event_t *);
if(event_is_type(e, EVENT_DYNAMIC_ACTION)) {
const event_payload_t *ep = (const event_payload_t *)e;
if(!strcmp(ep->payload, "dismiss")) {
rstr_t *id = prop_get_string(p, "id", NULL);
dismis_news(rstr_get(id));
rstr_release(id);
prop_destroy(opaque);
}
}
break;
default:
break;
}
va_end(ap);
}
static void
notifications_update(void *opaque, prop_event_t event, ...)
{
statusbar_t *sb = opaque;
prop_t *p, *txt;
statusbar_entry_t *sbe;
char *buf;
rstr_t *msg;
int i, l;
va_list ap;
va_start(ap, event);
switch(event) {
case PROP_ADD_CHILD:
p = va_arg(ap, prop_t *);
txt = prop_get_by_name(PNVEC("self", "text"), 1,
PROP_TAG_NAMED_ROOT, p, "self",
NULL);
if(txt != NULL) {
msg = prop_get_string(txt);
if(msg != NULL) {
buf = mystrdupa(rstr_get(msg));
l = strlen(buf);
for(i = 0; i < l; i++)
if(buf[i] < ' ')
buf[i] = ' ';
sbe = calloc(1, sizeof(statusbar_entry_t));
sbe->p = prop_ref_inc(p);
sbe->id = gtk_statusbar_push(GTK_STATUSBAR(sb->bar), sb->ctxid, buf);
LIST_INSERT_HEAD(&sb->entries, sbe, link);
rstr_release(msg);
}
prop_ref_dec(txt);
}
break;
case PROP_DEL_CHILD:
p = va_arg(ap, prop_t *);
LIST_FOREACH(sbe, &sb->entries, link)
if(sbe->p == p)
break;
if(sbe == NULL)
break;
prop_ref_dec(sbe->p);
gtk_statusbar_remove(GTK_STATUSBAR(sb->bar), sb->ctxid, sbe->id);
LIST_REMOVE(sbe, link);
free(sbe);
break;
default:
break;
}
}
static int
set_float3(glw_view_eval_context_t *ec, const token_attrib_t *a,
struct token *t)
{
const float *vec3;
float v[3];
switch(t->type) {
case TOKEN_VECTOR_FLOAT:
switch(t->t_elements) {
case 3:
vec3 = t->t_float_vector_int;
break;
default:
return glw_view_seterr(ec->ei, t,
"Attribute '%s': invalid vector size %d",
a->name, t->t_elements);
}
break;
case TOKEN_FLOAT:
v[0] = v[1] = v[2] = t->t_float;
vec3 = v;
break;
case TOKEN_INT:
v[0] = v[1] = v[2] = t->t_int;
vec3 = v;
break;
case TOKEN_VOID:
v[0] = v[1] = v[2] = 0;
vec3 = v;
break;
default:
return glw_view_seterr(ec->ei, t, "Attribute '%s' expects a vec3, got %s",
a->name, token2name(t));
}
glw_t *w = ec->w;
const glw_class_t *gc = w->glw_class;
int r = gc->gc_set_float3 ? gc->gc_set_float3(w, a->attrib, vec3) : -1;
if(r == -1) {
TRACE(TRACE_DEBUG, "GLW",
"Widget %s at %s:%d does not respond to attribute %s",
gc->gc_name, rstr_get(t->file), t->line, a->name);
return 0;
}
if(r)
attr_need_refresh(w->glw_root, t, a, r);
return 0;
}
static void *
bgloader_thread(void *aux)
{
bg_helper_t *bgh = aux;
rstr_t *current_bg = NULL;
float current_alpha = 0;
while(1) {
struct prop_notify_queue q;
float alpha = 1.0f;
int timo = alpha != current_alpha ? 16 : 0;
prop_courier_wait(bgh->pc, &q, timo);
prop_notify_dispatch(&q);
rstr_t *bg;
if(bgh->bg_url[0]) {
bg = bgh->bg_url[0];
if(bgh->bg_alpha[0])
alpha = bgh->bg_alpha[0];
} else if(bgh->bg_url[1]) {
bg = bgh->bg_url[1];
if(bgh->bg_alpha[1])
alpha = bgh->bg_alpha[1];
} else {
bg = bgh->bg_url[2];
}
if(bgh->fullwindow || bgh->screensaver)
alpha = 0;
if(alpha != current_alpha) {
if(current_alpha < alpha)
current_alpha = MIN(alpha, current_alpha + 0.1);
else if(current_alpha > alpha)
current_alpha = MAX(alpha, current_alpha - 0.1);
bgh->set_alpha(current_alpha, bgh->opaque);
}
if(!rstr_eq(current_bg, bg)) {
rstr_set(¤t_bg, bg);
const char *v[3];
v[0] = "skin";
v[1] = rstr_get(bgh->skin_path);
v[2] = NULL;
bgh->set_image(bg, v, bgh->opaque);
}
}
return NULL;
}
static void
input_req_event(void *opaque, event_t *e)
{
connman_service_t *cs = opaque;
if(cs->cs_input_req_inv == NULL)
return;
if(event_is_action(e, ACTION_OK)) {
rstr_t *username = prop_get_string(cs->cs_input_req_prop, "username", NULL);
rstr_t *password = prop_get_string(cs->cs_input_req_prop, "password", NULL);
GVariant *result;
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "Passphrase",
g_variant_new_string(rstr_get(password)));
if(cs->cs_input_req_want_identity)
g_variant_builder_add(builder, "{sv}", "Identity",
g_variant_new_string(rstr_get(username)));
result = g_variant_new("(a{sv})", builder);
TRACE(TRACE_DEBUG, "CONNMAN", "Auth response: %s",
g_variant_print(result, TRUE));
g_dbus_method_invocation_return_value(cs->cs_input_req_inv, result);
g_variant_builder_unref(builder);
rstr_release(username);
rstr_release(password);
connman_stop_input_request(cs);
}
if(event_is_action(e, ACTION_CANCEL)) {
g_dbus_method_invocation_return_dbus_error(cs->cs_input_req_inv,
"net.connman.Agent.Error.Canceled",
"Canceled by user");
connman_stop_input_request(cs);
}
}
static int
glw_segway_set_rstr_unresolved(glw_t *w, const char *a, rstr_t *value,
glw_style_t *gs)
{
if(!strcmp(a, "direction")) {
glw_segway_t *s = (glw_segway_t *)w;
s->direction = str2val(rstr_get(value), segway_directions);
return GLW_SET_RERENDER_REQUIRED;
}
return GLW_SET_NOT_RESPONDING;
}
static int
set_align(glw_view_eval_context_t *ec, const token_attrib_t *a,
struct token *t)
{
int v;
if(t->type != TOKEN_IDENTIFIER || (v = str2val(rstr_get(t->t_rstring), aligntab)) < 0)
return glw_view_seterr(ec->ei, t, "Invalid assignment for attribute %s",
a->name);
ec->w->glw_alignment = v;
return 0;
}
static int
set_transition_effect(glw_view_eval_context_t *ec, const token_attrib_t *a,
struct token *t)
{
int v;
if(t->type != TOKEN_IDENTIFIER || (v = str2val(rstr_get(t->t_rstring),
transitiontab)) < 0)
return glw_view_seterr(ec->ei, t, "Invalid assignment for attribute %s",
a->name);
glw_set(ec->w, GLW_ATTRIB_TRANSITION_EFFECT, v, NULL);
return 0;
}
int
nav_open_errorf(prop_t *root, rstr_t *fmt, ...)
{
va_list ap;
char buf[200];
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), rstr_get(fmt), ap);
va_end(ap);
rstr_release(fmt);
return nav_open_error(root, buf);
}
rstr_t *
metadata_remove_postfix_rstr(rstr_t *name)
{
if(!gconf.show_filename_extensions) {
const char *str = rstr_get(name);
int len = strlen(str);
if(len > 4 && str[len - 4] == '.')
return rstr_allocl(str, len - 4);
if(len > 5 && !strcasecmp(str + len - 5, ".m2ts"))
return rstr_allocl(str, len - 5);
}
return rstr_dup(name);
}
int
glw_view_attrib_resolve(token_t *t)
{
int i;
for(i = 0; i < sizeof(attribtab) / sizeof(attribtab[0]); i++)
if(!strcmp(attribtab[i].name, rstr_get(t->t_rstring))) {
rstr_release(t->t_rstring);
t->t_attrib = &attribtab[i];
t->type = TOKEN_OBJECT_ATTRIBUTE;
return 0;
}
return -1;
}
/**
* Load a file using the 'glw_rawloader' method
*
* Returns pointer to last token, or NULL if an error occured.
* If an error occured 'ei' will be filled with data
*
*/
token_t *
glw_view_load1(glw_root_t *gr, rstr_t *url, errorinfo_t *ei, token_t *prev)
{
char *src;
token_t *last;
char errbuf[256];
rstr_t *p = fa_absolute_path(url, prev->file);
src = fa_load(rstr_get(p), NULL, gr->gr_vpaths,
errbuf, sizeof(errbuf), NULL, 0, NULL, NULL);
if(src == NULL) {
snprintf(ei->error, sizeof(ei->error), "Unable to open \"%s\" -- %s",
rstr_get(p), errbuf);
snprintf(ei->file, sizeof(ei->file), "%s", rstr_get(prev->file));
ei->line = prev->line;
rstr_release(p);
return NULL;
}
last = lexer(gr, src, ei, p, prev);
free(src);
rstr_release(p);
return last;
}
static int
set_caption(glw_view_eval_context_t *ec, const token_attrib_t *a,
struct token *t)
{
char buf[30];
const char *str;
prop_str_type_t type = 0;
switch(t->type) {
case TOKEN_VOID:
str = NULL;
break;
case TOKEN_CSTRING:
str = t->t_cstring;
break;
case TOKEN_RSTRING:
type = t->t_rstrtype;
/* FALLTHRU */
case TOKEN_LINK:
str = rstr_get(t->t_rstring);
break;
case TOKEN_INT:
snprintf(buf, sizeof(buf), "%d", t->t_int);
str = buf;
break;
case TOKEN_FLOAT:
snprintf(buf, sizeof(buf), "%f", t->t_float);
str = buf;
break;
default:
return glw_view_seterr(ec->ei, t,
"Attribute '%s' expects a string or scalar, got %s",
a->name, token2name(t));
}
if(ec->w->glw_class->gc_set_caption != NULL)
ec->w->glw_class->gc_set_caption(ec->w, str, type);
return 0;
}
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 int
search_open(prop_t *page, const char *url0)
{
const char *url;
prop_t *model, *meta, *source;
char title[256];
if((url = strchr(url0, ':')) == NULL)
abort();
url++;
if(!backend_open(page, url))
return 0;
model = prop_create(page, "model");
prop_set_string(prop_create(model, "type"), "directory");
meta = prop_create(model, "metadata");
rstr_t *fmt = _("Search result for: %s");
snprintf(title, sizeof(title), rstr_get(fmt), url);
rstr_release(fmt);
prop_set_string(prop_create(meta, "title"), title);
source = prop_create(page, "source");
struct prop_nf *pnf;
pnf = prop_nf_create(prop_create(model, "nodes"),
prop_create(source, "nodes"),
NULL, PROP_NF_AUTODESTROY);
prop_nf_sort(pnf, "node.metadata.title", 0, 2, NULL, 1);
prop_nf_pred_int_add(pnf, "node.entries",
PROP_NF_CMP_EQ, 0, NULL,
PROP_NF_MODE_EXCLUDE);
prop_nf_release(pnf);
backend_search(source, url);
return 0;
}
static JSBool
js_createString(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
js_setting_group_t *jsg = JS_GetPrivate(cx, obj);
const char *id;
const char *title;
const char *def;
JSObject *func;
JSBool persistent = JS_FALSE;
if(!JS_ConvertArguments(cx, argc, argv, "ssso/b",
&id, &title, &def, &func, &persistent))
return JS_FALSE;
js_setting_t *jss = jss_create(cx, obj, id, rval, func, jsg, persistent);
if(jss == NULL)
return JS_FALSE;
rstr_t *r = NULL;
if(persistent && jsg->jsg_kv_url) {
r = kv_url_opt_get_rstr(jsg->jsg_kv_url, KVSTORE_DOMAIN_PLUGIN, id);
if(r != NULL)
def = rstr_get(r);
}
jss->jss_s =
setting_create(SETTING_STRING, jsg->jsg_root,
SETTINGS_INITIAL_UPDATE | jsg->jsg_settings_flags,
SETTING_TITLE_CSTR(title),
SETTING_COURIER(js_global_pc),
SETTING_VALUE(def),
SETTING_CALLBACK(js_store_update_string, jss),
SETTING_HTSMSG_CUSTOM_SAVER(id, jsg->jsg_store,
js_setting_group_save, jsg),
NULL);
jss->jss_cx = NULL;
rstr_release(r);
return JS_TRUE;
}
