mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/lib/libdom/domstyle.c

1191 строка
35 KiB
C
Исходник Ответственный История

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
/*
* DOM Style information, using JSSS.
*/
#include "domstyle.h"
#include "dom_priv.h"
#ifdef DEBUG_shaver
/* #define DEBUG_shaver_style_primitives 1 */
/* #define DEBUG_shaver_verbose 1 */
/* #define DEBUG_shaver_SME 1 */
#endif
#define STYLE_DB_FROM_CX(db, cx) \
PR_BEGIN_MACRO \
{ \
(db) = DOM_StyleDatabaseFromContext(cx); \
if (!db) \
return JS_FALSE; \
} \
PR_END_MACRO
/* if either is present, they must both be and match */
#define PSEUDO_MATCHES(p1, p2) ((p1 || p2) ? \
(p1 && p2 && !XP_STRCMP(p1, p2)) : \
JS_TRUE)
static int
CompareSelectors(const void *v1, const void *v2)
{
DOM_StyleSelector *s1 = (DOM_StyleSelector *)v1,
*s2 = (DOM_StyleSelector *)v2;
return s1->type == s2->type &&
!XP_STRCMP(s1->selector, s2->selector) &&
/* if both have a psuedo, they have to match, else both must be NULL */
(s1->pseudo && s2->pseudo ?
XP_STRCMP(s1->pseudo, s2->pseudo) :
!s1->pseudo && !s2->pseudo);
}
DOM_StyleDatabase *
DOM_NewStyleDatabase(JSContext *cx)
{
DOM_StyleDatabase *db = XP_NEW_ZAP(DOM_StyleDatabase);
if (!db)
return NULL;
db->ht = PL_NewHashTable(32, PL_HashString, PL_CompareStrings,
CompareSelectors, NULL, NULL);
if (!db->ht) {
XP_FREE(db);
return NULL;
}
return db;
}
void
DOM_DestroyStyleDatabase(JSContext *cx, DOM_StyleDatabase *db)
{
PL_HashTableDestroy(db->ht);
XP_FREE(db);
}
static JSBool
InsertBaseSelector(JSContext *cx, DOM_StyleDatabase *db,
DOM_StyleSelector *sel)
{
DOM_StyleSelector *base, *iter;
base = PL_HashTableLookup(db->ht, sel->selector);
if (!base) {
return PL_HashTableAdd(db->ht, sel->selector, sel) != NULL;
}
/*
* We need to keep these properly ordered, so that we always find the
* best match first. This means that "selector"/"extra" must always
* appear before "selector"/NULL.
*/
if (sel->extra) {
/* these go at the beginning, so we can stick it right here */
sel->sibling = base;
return PL_HashTableRemove(db->ht, sel->selector) &&
(PL_HashTableAdd(db->ht, sel->selector, sel) != NULL);
}
/*
* This is O(n), which is a bit sucky. We could cache the tail
* somewhere if it becomes an issue.
*/
for (iter = base; iter->sibling; iter = iter->sibling)
/* nothing */ ;
iter->sibling = sel;
return JS_TRUE;
}
/*
* Does the selector match the tokens (the parts that matter for this class)?
* strict means that document.classes.foo.all does NOT match
* document.classes.foo.H4, for example.
*/
static JSBool
SelectorMatchesToken(JSContext *cx, DOM_StyleSelector *sel, uint8 type,
DOM_StyleToken token, DOM_StyleToken extra,
DOM_StyleToken pseudo, JSBool strict)
{
if (sel->type != type ||
XP_STRCMP(sel->selector, token))
return JS_FALSE;
switch (type) {
case SELECTOR_CLASS:
if (strict) {
if (!PSEUDO_MATCHES(sel->extra, extra))
return JS_FALSE;
} else {
if (sel->extra && (!extra || XP_STRCMP(extra, sel->extra)))
return JS_FALSE;
}
/* FALLTHROUGH */
case SELECTOR_TAG:
if (strict) {
if (!PSEUDO_MATCHES(sel->pseudo, pseudo))
return JS_FALSE;
} else {
if (sel->pseudo && (!pseudo || XP_STRCMP(pseudo, sel->pseudo)))
return JS_FALSE;
}
case SELECTOR_ID:
return JS_TRUE;
default:
XP_ASSERT(0 && "unknown selector type in base selector");
return JS_FALSE;
}
}
static DOM_StyleSelector *
GetBaseSelector(JSContext *cx, DOM_StyleDatabase *db, uint8 type,
DOM_StyleToken token, DOM_StyleToken extra,
DOM_StyleToken pseudo, JSBool strict)
{
DOM_StyleSelector *sel;
if (!cx)
return NULL;
if (!db) {
db = DOM_StyleDatabaseFromContext(cx);
#ifdef DEBUG_shaver
fprintf(stderr, "got new db %p\n", db);
#endif
if (!db)
return NULL;
}
sel = PL_HashTableLookup(db->ht, token);
for (; sel; sel = sel->sibling) {
if (SelectorMatchesToken(cx, sel, type, token, extra, pseudo, strict))
return sel;
}
return NULL;
}
static void
DestroySelector(JSContext *cx, DOM_StyleSelector *sel)
{
XP_FREE((char *)sel->selector);
if (sel->pseudo)
XP_FREE((char *)sel->pseudo);
if (sel->extra)
XP_FREE((char *)sel->extra);
if (sel->rules) {
DOM_StyleRule *iter, *next;
iter = sel->rules;
do {
next = iter->next;
XP_FREE((char *)iter->entry.name);
XP_FREE((char *)iter->entry.value);
XP_FREE(iter);
iter = next;
} while (iter);
}
XP_FREE(sel);
}
static DOM_StyleSelector *
NewSelector(JSContext *cx, uint8 type, DOM_StyleToken selector,
DOM_StyleToken extra, DOM_StyleToken pseudo)
{
DOM_StyleSelector *sel;
sel = XP_NEW_ZAP(DOM_StyleSelector);
if (!sel)
return NULL;
sel->type = type;
sel->selector = XP_STRDUP(selector);
if (!sel->selector) {
DestroySelector(cx, sel);
return NULL;
}
if (pseudo) {
sel->pseudo = XP_STRDUP(pseudo);
if (!sel->pseudo) {
DestroySelector(cx, sel);
return NULL;
}
}
if (extra) {
sel->extra = XP_STRDUP(extra);
if (!sel->extra) {
DestroySelector(cx, sel);
return NULL;
}
}
return sel;
}
/* the pseudoclass, if any, is stored in a magic attribute */
DOM_StyleToken
DOM_GetElementPseudo(JSContext *cx, DOM_Element *element)
{
DOM_AttributeEntry *entry;
if (!DOM_GetElementAttribute(cx, element, "dom:pseudoclass", &entry))
/* report error? */
return NULL;
return entry ? entry->value : NULL;
}
JSBool
DOM_SetElementPseudo(JSContext *cx, DOM_Element *element,
DOM_StyleToken pseudo)
{
/* don't run the callbacks for attribute setting */
return dom_SetElementAttribute(cx, element, XP_STRDUP("dom:pseudoclass"),
XP_STRDUP(pseudo), JS_FALSE);
}
#ifdef DEBUG_shaver_SME
#define MATCH() \
fprintf(stderr, "[selector %s:%s matches element %s:%s]", \
sel->selector, sel->pseudo ? sel->pseudo : "<none>", \
element->tagName, elementPseudo);
#else
#define MATCH()
#endif
#ifdef DEBUG_shaver_SME
#define NO_MATCH() \
fprintf(stderr, "[selector %s:%s doesn't match element %s:%s]", \
sel->selector, sel->pseudo ? sel->pseudo : "<none>", \
element->tagName, elementPseudo);
#else
#define NO_MATCH()
#endif
static JSBool
SelectorMatchesElement(JSContext *cx, DOM_Element *element,
DOM_StyleSelector *sel)
{
DOM_StyleToken elementPseudo = DOM_GetElementPseudo(cx, element);
#ifdef DEBUG_shaver_SME
fprintf(stderr,
"[checking selector %d:%s/%s:%s against element %s/%s/%s:%s]",
sel->type, sel->selector, sel->extra, sel->pseudo,
element->styleID, element->styleClass, element->tagName,
elementPseudo);
#endif
switch(sel->type) {
case SELECTOR_TAG:
if (XP_STRCMP(sel->selector, element->tagName))
return JS_FALSE;
/* check pseudo, if any */
if (sel->pseudo) {
if (PSEUDO_MATCHES(sel->pseudo, elementPseudo)) {
MATCH();
return JS_TRUE;
}
NO_MATCH();
return JS_FALSE;
} else {
MATCH();
return JS_TRUE;
}
case SELECTOR_ID:
return element->styleID && !XP_STRCMP(sel->selector, element->styleID);
case SELECTOR_CLASS:
if (XP_STRCMP(sel->selector, element->styleClass) ||
(sel->extra && XP_STRCMP(sel->extra, element->tagName)))
return JS_FALSE;
return JS_TRUE;
}
return JS_FALSE;
}
static DOM_AttributeEntry *
RuleValueFor(JSContext *cx, DOM_StyleRule *rule, DOM_StyleToken property)
{
DOM_StyleRule *iter = rule;
do {
if (!XP_STRCMP(iter->entry.name, property)) {
return &iter->entry;
}
iter = iter->next;
} while (iter);
return NULL;
}
static DOM_StyleRule *
AddRule(JSContext *cx, DOM_StyleSelector *sel, const char *name,
const char *value, int16 weight)
{
DOM_StyleRule *rule;
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "adding rule %s = %s to %d:%s/%s:%s\n", name, value,
sel->type, sel->selector, sel->extra, sel->pseudo);
#endif
rule = XP_NEW_ZAP(DOM_StyleRule);
if (!rule)
return NULL;
rule->entry.name = XP_STRDUP(name);
rule->entry.value = XP_STRDUP(value);
rule->entry.dirty = JS_TRUE;
rule->weight = weight;
rule->next = sel->rules;
sel->rules = rule;
return rule;
}
/* Find the parent element of appropriate type for given element */
static DOM_Element *
AncestorOfType(JSContext *cx, DOM_Element *element, DOM_StyleSelector *sel)
{
do {
/* check type */
if (SelectorMatchesElement(cx, element, sel)) {
return element;
}
element = (DOM_Element *)element->node.parent;
} while (element && element->node.type == NODE_TYPE_ELEMENT);
return NULL;
}
/*
* From libstyle/jssrules.h:
* "Specificity is implemented as three 8-bit components: the number
* of tags in the selector (the least significant component), the
* number of classes in the selector, and the number of ids in the
* selector (the most significant component)."
*
* We use the lower 8 bits to count the ``enclosure depth'' of a rule
* in SELECTOR_SCORE below, so that "H1 EM {color:blue}" can override
* "EM {color:red}" without interfering with the other specificity
* scores. Because we use the lower 8 bits for this, the depth will
* only matter for selectors that otherwise had the same score, unless
* we get a depth of more than 255 elements. In that case, I'll try
* to care.
*/
#define CSS_SPECIFICITY(ids, classes, tags) \
((uint32)(ids << 24) | (uint32)(classes << 16) | (uint32)(tags << 8))
static uint32
ScoreSelector(DOM_StyleSelector *sel)
{
switch(sel->type) {
case SELECTOR_ID:
return CSS_SPECIFICITY(1, 0, 0);
case SELECTOR_CLASS:
if (sel->extra) /* sel->extra is NULL for .all */
return CSS_SPECIFICITY(0, 1, 1);
else
return CSS_SPECIFICITY(0, 1, 0);
case SELECTOR_TAG:
return CSS_SPECIFICITY(0, 0, 1);
default:
XP_ASSERT(0 && "bogus selector type in ScoreSelector");
return 0;
}
}
#define SELECTOR_SCORE(sel, specificity) (ScoreSelector(sel) + specificity)
/*
* Determine if the given selector is a best-yet match for element, and
* recurse/iterate appropriately over enclosing and sibling elements.
*/
static JSBool
CheckSelector(JSContext *cx, DOM_Element *element, DOM_StyleSelector *sel,
DOM_StyleToken property, DOM_AttributeEntry **entryp,
uintN *best, uintN specificity)
{
DOM_AttributeEntry *entry;
DOM_Element *next;
DOM_StyleSelector *iter;
/* check self */
if (SelectorMatchesElement(cx, element, sel)) {
/* if we have rules, maybe get an entry from them */
if (sel->rules) {
uintN score = SELECTOR_SCORE(sel, specificity);
if (score > *best) { /* are we the best so far? */
entry = RuleValueFor(cx, sel->rules, property);
if (entry) { /* do we have a value for this property? */
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "[+SCORE %d, VALUE %s]", score,
entry->value);
#endif
*best = score;
*entryp = entry;
}
} else {
#ifdef DEBUG_shaver_style_primitives
entry = RuleValueFor(cx, sel->rules, property);
if (entry) { /* do we have a value for this property? */
fprintf(stderr, "[-score %d, value %s]", score,
entry->value);
}
#endif
}
}
/* now, check our enclosing selector */
iter = sel->enclosing;
while(iter) {
next = AncestorOfType(cx, element, iter);
if (next) {
if (!CheckSelector(cx, next, iter, property, entryp,
best, specificity + 1))
return JS_FALSE;
return JS_TRUE;
}
iter = iter->sibling;
}
}
/* check our sibling */
if (sel->sibling)
if (!CheckSelector(cx, element, sel->sibling, property, entryp,
best, specificity))
return JS_FALSE;
return JS_TRUE;
}
JSBool
DOM_StyleGetProperty(JSContext *cx, DOM_StyleDatabase *db,
DOM_Node *node, DOM_StyleToken property,
DOM_AttributeEntry **entryp)
{
DOM_StyleSelector *sel;
DOM_Element *element, *iter;
JSBool ok;
uintN best = 0;
uint8 type;
*entryp = NULL;
if (node->type != NODE_TYPE_ELEMENT) {
element = (DOM_Element *)node->parent;
if (!element || element->node.type != NODE_TYPE_ELEMENT)
return JS_TRUE;
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "(node is type %d, using parent %d/%s:%s@%p) ",
node->type, node->parent->type, element->tagName,
DOM_GetElementPseudo(cx, element), node->parent);
#endif
} else {
element = (DOM_Element *)node;
}
if (!db)
STYLE_DB_FROM_CX(db, cx);
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "\nGetProperty: looking for %s/%s/%s:%s.%s: ",
element->styleID, element->styleClass, element->tagName,
DOM_GetElementPseudo(cx, element), property);
#endif
/*
* We have to handle TAGs, .classes and #IDs. Basically, we run through
* this loop 3 times, finding the best match for IDs, then classes, then
* tags.
*/
iter = element;
do {
const char *token, *extra, *pseudo;
pseudo = DOM_GetElementPseudo(cx, iter);
for (type = SELECTOR_ID; type <= SELECTOR_TAG; type++) {
switch(type) {
case SELECTOR_ID:
token = iter->styleID;
extra = NULL;
break;
case SELECTOR_CLASS:
token = iter->styleClass;
extra = iter->tagName;
break;
case SELECTOR_TAG:
token = iter->tagName;
extra = NULL;
break;
default:
continue;
}
if (!token)
continue;
sel = GetBaseSelector(cx, db, type, token, extra, pseudo,
JS_FALSE);
if (sel) {
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "[BASE selector for %d:%s/%s:%s -- checking]",
type, token, extra, pseudo);
#endif
ok = CheckSelector(cx, iter, sel, property, entryp, &best, 0);
if (ok) {
/*
* the first one we find that gives this property is
* correct, because we check the innermost nodes first.
*/
if (*entryp) {
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "found %s ", (*entryp)->value);
#endif
goto found_it; /* oh, for a labelled break */
}
} else {
#ifdef DEBUG_shaver
fprintf(stderr, "CheckSelector failed\n");
#endif
return JS_FALSE;
}
}
}
iter = (DOM_Element *)iter->node.parent;
} while (iter && iter->node.type == NODE_TYPE_ELEMENT);
found_it:
#ifdef DEBUG_shaver_verbose
if (!sel)
fprintf(stderr, "no base selector found");
else
#endif
#ifdef DEBUG_shaver_style_primitives
if (!*entryp)
fprintf(stderr, "no match found");
fputs("\n", stderr);
#endif
return JS_TRUE;
}
DOM_AttributeEntry *
DOM_StyleAddRule(JSContext *cx, DOM_StyleDatabase *db, DOM_StyleSelector *sel,
DOM_StyleToken name, const char *value)
{
DOM_StyleRule *rule;
DOM_AttributeEntry *entry;
if (sel->rules) {
entry = RuleValueFor(cx, sel->rules, name);
if (entry) {
if (!XP_STRCMP(entry->value, value))
return entry;
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "overwriting %s=%s with %s=%s\n", name,
entry->value, name, value);
#endif
XP_FREE((char *)entry->value);
entry->value = XP_STRDUP(value);
if (!entry->value)
return NULL;
entry->dirty = JS_TRUE;
return entry;
}
}
/*
* XXXshaver we should allow a weight to be specified as well, so that
* user-agent/author/user sheets can compete correctly. Right now, we
* always use a weight of 0.
*/
rule = AddRule(cx, sel, name, value, 0);
if (!rule)
return NULL;
return &rule->entry;
}
static DOM_StyleSelector *
FindSelector(JSContext *cx, DOM_StyleDatabase *db, DOM_StyleSelector *base,
uint8 type, DOM_StyleToken enclosing, DOM_StyleToken extra,
DOM_StyleToken pseudo)
{
DOM_StyleSelector *sel;
/* looking for the base one */
if (!base) {
sel = GetBaseSelector(cx, db, type, enclosing, extra, pseudo, JS_TRUE);
if (!sel) {
sel = NewSelector(cx, type, enclosing, extra, pseudo);
if (!sel)
return NULL;
InsertBaseSelector(cx, db, sel);
}
return sel;
}
/* check existing enclosing selectors */
for(sel = base->enclosing; sel; sel = sel->sibling) {
if (SelectorMatchesToken(cx, sel, type, enclosing, extra, pseudo,
JS_TRUE))
return sel;
}
/* nothing found that matches, so create a new one */
sel = NewSelector(cx, type, enclosing, extra, pseudo);
if (!sel)
return NULL;
sel->sibling = base->enclosing;
base->enclosing = sel;
return sel;
}
#define HANDLE_SELECTOR_TYPE(token, type) \
PR_BEGIN_MACRO \
if (*token == '.') { \
type = SELECTOR_CLASS; \
token++; \
} else if (*token == '#') { \
type = SELECTOR_ID; \
token++; \
} else { \
type = SELECTOR_TAG; \
} \
PR_END_MACRO
DOM_StyleSelector *
DOM_StyleFindSelector(JSContext *cx, DOM_StyleDatabase *db,
DOM_StyleSelector *base, DOM_StyleToken enclosing,
DOM_StyleToken pseudo)
{
uint8 type;
HANDLE_SELECTOR_TYPE(enclosing, type);
return FindSelector(cx, db, base, type, enclosing, NULL, pseudo);
}
DOM_StyleSelector *
DOM_StyleFindSelectorFull(JSContext *cx, DOM_StyleDatabase *db,
DOM_StyleSelector *base, uint8 type,
DOM_StyleToken enclosing, DOM_StyleToken extra,
DOM_StyleToken pseudo)
{
if (type == SELECTOR_ID)
extra = NULL;
return FindSelector(cx, db, base, type, enclosing, extra, pseudo);
}
/*
* JS classes
*/
/*
* StyleSelector class: document.tags.H1 or contextual(tags.H1, tags.EM) or
* document.ids.mine or document.classes.punk.all or whatever.
*/
static JSBool
StyleSelector_setProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
DOM_StyleSelector *sel;
DOM_StyleDatabase *db;
JSString *rule, *value;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
sel = JS_GetPrivate(cx, obj);
if (!sel)
return JS_TRUE;
rule = JSVAL_TO_STRING(id);
value = JS_ValueToString(cx, *vp);
if (!value)
return JS_FALSE;
STYLE_DB_FROM_CX(db, cx);
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "%s.", sel->selector);
switch (sel->type) {
case SELECTOR_CLASS:
fprintf(stderr, "%s.", sel->extra ? sel->extra : "all");
break;
default:
break;
}
fprintf(stderr, "%s = %s\n", JS_GetStringBytes(rule),
JS_GetStringBytes(value));
#endif
return DOM_StyleAddRule(cx, db, sel, JS_GetStringBytes(rule),
JS_GetStringBytes(value)) != NULL;
}
static JSBool
StyleSelector_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
return JS_TRUE;
}
static JSBool
StyleSelector_convert(JSContext *cx, JSObject *obj, JSType hint, jsval *vp)
{
JSString *str;
DOM_StyleSelector *sel;
if (hint == JSTYPE_STRING) {
/* XXXshaver handle A.class:visited and A#id, etc. */
char * selstring;
uintN len;
sel = JS_GetPrivate(cx, obj);
if (!sel || !sel->selector)
return JS_TRUE;
if (sel->pseudo) {
/* "selector:pseudo" */
selstring = JS_malloc(cx, (len = XP_STRLEN(sel->selector)) +
XP_STRLEN(sel->pseudo) +
2 /* : and \0 */);
if (!selstring)
return JS_FALSE;
XP_STRCPY(selstring, sel->selector);
selstring[len] = ':';
selstring[len + 1] = '\0';
XP_STRCAT(selstring, sel->pseudo);
} else {
selstring = (char *)sel->selector;
}
str = JS_NewStringCopyZ(cx, selstring);
if (sel->pseudo)
JS_free(cx, selstring);
if (!str)
return JS_FALSE;
*vp = STRING_TO_JSVAL(str);
}
return JS_TRUE;
}
static JSBool
StyleSelector_resolve(JSContext *cx, JSObject *obj, jsval id)
{
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
/* XXX we should check that it's a valid JSSS property name first */
return JS_DefineProperty(cx, obj, JS_GetStringBytes(JSVAL_TO_STRING(id)),
JSVAL_VOID, 0, 0,
JSPROP_ENUMERATE | JSPROP_PERMANENT);
}
static JSClass StyleSelectorClass = {
"StyleSelector", JSCLASS_HAS_PRIVATE,
JS_PropertyStub, JS_PropertyStub, StyleSelector_getProperty,
StyleSelector_setProperty, JS_EnumerateStub, StyleSelector_resolve,
StyleSelector_convert, JS_FinalizeStub
};
static JSBool
StyleSelector(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
jsval *rval)
{
return JS_TRUE;
}
JSObject *
dom_StyleSelectorInit(JSContext *cx, JSObject *scope)
{
JSObject *proto;
proto = JS_InitClass(cx, scope, NULL, &StyleSelectorClass,
StyleSelector, 0,
0, 0, 0, 0);
return proto;
}
JSObject *
DOM_NewStyleSelectorObject(JSContext *cx, DOM_StyleSelector *sel)
{
JSObject *obj;
obj = JS_ConstructObject(cx, &StyleSelectorClass, NULL, NULL);
if (!obj)
return NULL;
if (!JS_SetPrivate(cx, obj, sel))
return NULL;
sel->mocha_object = obj;
return obj;
}
JSObject *
DOM_ObjectForStyleSelector(JSContext *cx, DOM_StyleSelector *sel)
{
if (!sel)
return NULL;
if (sel->mocha_object)
return sel->mocha_object;
return DOM_NewStyleSelectorObject(cx, sel);
}
/*
* Tags object: document.tags
*/
static JSBool
Tags_resolve(JSContext *cx, JSObject *obj, jsval id)
{
JSString *tag;
DOM_StyleDatabase *db;
char *tagString, *pseudo, *selName;
DOM_StyleSelector *sel;
JSObject *tagObj;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
STYLE_DB_FROM_CX(db, cx);
tag = JSVAL_TO_STRING(id);
/* XXXshaver use GetStringChars and DefinePropertyUC? */
tagString = JS_GetStringBytes(tag);
if (!tagString)
return JS_FALSE;
#ifdef DEBUG_shaver
fprintf(stderr, "tags.%s\n", tagString);
#endif
pseudo = strchr(tagString, ':');
if (pseudo) {
ptrdiff_t pseudoOff = pseudo - tagString;
selName = XP_STRDUP(tagString);
if (!selName)
return JS_FALSE;
selName[pseudoOff] = 0;
pseudo = selName + pseudoOff + 1;
#ifdef DEBUG_shaver
fprintf(stderr, "found pseudo: \"%s\":\"%s\"\n", selName, pseudo);
#endif
} else {
selName = tagString;
}
sel = DOM_StyleFindSelectorFull(cx, db, NULL, SELECTOR_TAG,
selName, NULL, pseudo);
if (pseudo)
XP_FREE(selName);
tagObj = DOM_ObjectForStyleSelector(cx, sel);
return JS_DefineProperty(cx, obj, tagString, OBJECT_TO_JSVAL(tagObj),
0, 0, JSPROP_ENUMERATE | JSPROP_PERMANENT);
}
static JSClass TagsClass = {
"Tags", JSCLASS_HAS_PRIVATE,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
JS_EnumerateStub, Tags_resolve, JS_ConvertStub, JS_FinalizeStub
};
static JSObject *
TagsObjectInit(JSContext *cx, JSObject *scope)
{
JSObject *obj = JS_NewObject(cx, &TagsClass, NULL, scope);
return obj;
}
/*
* Classes object: document.classes and document.classes.punk
*/
static void
ClassHolder_finalize(JSContext *cx, JSObject *obj)
{
char *cls = JS_GetPrivate(cx, obj);
if (cls)
XP_FREE(cls);
}
static JSBool
ClassHolder_resolve(JSContext *cx, JSObject *obj, jsval id)
{
JSString *tag;
DOM_StyleDatabase *db;
char *clsString, *tagString, *extra;
DOM_StyleSelector *sel;
JSObject *clsObj;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
clsString = JS_GetPrivate(cx, obj);
if (!clsString)
return JS_TRUE;
STYLE_DB_FROM_CX(db, cx);
tag = JSVAL_TO_STRING(id);
/* XXXshaver use GetStringChars and DefinePropertyUC? */
tagString = JS_GetStringBytes(tag);
if (!tagString)
return JS_FALSE;
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "classes.%s.%s\n", clsString, tagString);
#endif
/* XXX handle pseudo */
if (XP_STRCMP(tagString, "all"))
extra = tagString;
else
extra = NULL;
sel = DOM_StyleFindSelectorFull(cx, db, NULL, SELECTOR_CLASS,
clsString, extra, NULL);
clsObj = DOM_ObjectForStyleSelector(cx, sel);
return JS_DefineProperty(cx, obj, tagString, OBJECT_TO_JSVAL(clsObj),
0, 0, JSPROP_ENUMERATE | JSPROP_PERMANENT);
}
static JSClass ClassHolderClass = {
"ClassHolder", JSCLASS_HAS_PRIVATE,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
JS_EnumerateStub, ClassHolder_resolve, JS_ConvertStub, ClassHolder_finalize
};
static JSObject *
ClassHolder(JSContext *cx, const char *cls)
{
char *clsDup;
JSObject *obj = JS_NewObject(cx, &ClassHolderClass, NULL,
JS_GetGlobalObject(cx));
if (!obj)
return NULL;
clsDup = XP_STRDUP(cls);
if (!clsDup)
return NULL;
if (!JS_SetPrivate(cx, obj, clsDup))
return NULL;
return obj;
}
static JSBool
Classes_resolve(JSContext *cx, JSObject *obj, jsval id)
{
JSString *cls;
char *clsString;
JSObject *clsObj;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
cls = JSVAL_TO_STRING(id);
/* XXXshaver use GetStringChars and DefinePropertyUC? */
clsString = JS_GetStringBytes(cls);
if (!clsString)
return JS_FALSE;
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "classes.%s\n", clsString);
#endif
clsObj = ClassHolder(cx, clsString);
if (!clsObj)
return JS_FALSE;
return JS_DefineProperty(cx, obj, clsString, OBJECT_TO_JSVAL(clsObj),
0, 0, JSPROP_ENUMERATE | JSPROP_PERMANENT);
}
static JSClass ClassesClass = {
"Classes", 0,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
JS_EnumerateStub, Classes_resolve, JS_ConvertStub, JS_FinalizeStub
};
static JSObject *
ClassesObjectInit(JSContext *cx, JSObject *scope)
{
JSObject *obj = JS_NewObject(cx, &ClassesClass, NULL, scope);
return obj;
}
/*
* Ids object: document.ids
*/
static JSBool
Ids_resolve(JSContext *cx, JSObject *obj, jsval id)
{
JSString *str;
DOM_StyleDatabase *db;
char *idString;
DOM_StyleSelector *sel;
JSObject *idObj;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
STYLE_DB_FROM_CX(db, cx);
str = JSVAL_TO_STRING(id);
/* XXXshaver use GetStringChars and DefinePropertyUC? */
idString = JS_GetStringBytes(str);
if (!idString)
return JS_FALSE;
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "ids.%s\n", idString);
#endif
/* XXX handle pseudo and tag */
sel = DOM_StyleFindSelectorFull(cx, db, NULL, SELECTOR_ID,
idString, NULL, NULL);
idObj = DOM_ObjectForStyleSelector(cx, sel);
return JS_DefineProperty(cx, obj, idString, OBJECT_TO_JSVAL(idObj),
0, 0, JSPROP_ENUMERATE | JSPROP_PERMANENT);
}
static JSClass IdsClass = {
"Ids", 0,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
JS_EnumerateStub, Ids_resolve, JS_ConvertStub, JS_FinalizeStub
};
static JSObject *
IdsObjectInit(JSContext *cx, JSObject *scope)
{
JSObject *obj = JS_NewObject(cx, &IdsClass, NULL, scope);
return obj;
}
JSBool
DOM_DocObjectResolveStyleProps(JSContext *cx, JSObject *obj, jsval id)
{
char *name;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
name = JS_GetStringBytes(JSVAL_TO_STRING(id));
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "resolving document.%s\n", name);
#endif
if (!XP_STRCMP(name, "tags")) {
JSObject *tags;
tags = TagsObjectInit(cx, obj);
if (!tags)
return JS_FALSE;
return JS_DefineProperty(cx, obj, "tags", OBJECT_TO_JSVAL(tags),
0, 0, JSPROP_ENUMERATE | JSPROP_PERMANENT);
} else if (!XP_STRCMP(name, "classes")) {
JSObject *classes;
classes = ClassesObjectInit(cx, obj);
if (!classes)
return JS_FALSE;
return JS_DefineProperty(cx, obj, "classes", OBJECT_TO_JSVAL(classes),
0, 0, JSPROP_ENUMERATE | JSPROP_PERMANENT);
} else if (!XP_STRCMP(name, "ids")) {
JSObject *ids;
ids = IdsObjectInit(cx, obj);
if (!ids)
return JS_FALSE;
return JS_DefineProperty(cx, obj, "ids", OBJECT_TO_JSVAL(ids),
0, 0, JSPROP_ENUMERATE | JSPROP_PERMANENT);
} else if (!XP_STRCMP(name, "contextual")) {
return (JSBool)(JS_DefineFunction(cx, obj, "contextual",
DOM_JSContextual, 1, 0) != NULL);
}
return JS_TRUE;
}
/*
* Return a contextual selector: contextual("H1", tags.EM);
*/
JSBool
DOM_JSContextual(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
jsval *rval)
{
DOM_StyleDatabase *db;
intN i;
DOM_StyleSelector *sel = NULL;
JSObject *selObj;
JSString *str;
if (!argc)
return JS_TRUE;
STYLE_DB_FROM_CX(db, cx);
for (i = argc - 1; i >= 0; i--) {
JSObject *obj2;
const char *selName, *selPseudo, *selExtra;
int8 selType;
if (JSVAL_IS_OBJECT(argv[i]) &&
(obj2 = JSVAL_TO_OBJECT(argv[i]),
#ifdef JS_THREADSAFE
JS_GetClass(cx, obj2)
#else
JS_GetClass(obj2)
#endif
== &StyleSelectorClass)) {
/* tags.H1 or ids.mine or classes.punk.all */
DOM_StyleSelector *sel2 = JS_GetPrivate(cx, obj2);
if (!sel2)
/* have prototype, will travel (and ignore it) */
continue;
selName = sel2->selector;
selType = sel2->type;
selExtra = sel2->extra;
selPseudo = sel2->pseudo;
} else {
/* "H1" or ".myclass" or "#ID" or whatever */
str = JS_ValueToString(cx, argv[i]);
if (!str)
return JS_FALSE;
selName = JS_GetStringBytes(str);
if (!selName)
return JS_FALSE;
/* XXX parse and handle class/id and pseudo/extra! */
selPseudo = NULL;
selExtra = NULL;
selType = SELECTOR_TAG;
}
#ifdef DEBUG_shaver_style_primitives
fprintf(stderr, "contextual: going from %d:%s/%s to %d:%s/%s\n",
sel ? sel->type : -1, sel ? sel->selector : "<none>",
sel ? sel->extra : "<none>", selType, selName, selExtra);
#endif
sel = DOM_StyleFindSelectorFull(cx, db, sel, selType, selName,
selExtra, selPseudo);
if (!sel) {
JS_ReportError(cx, "Error getting selector %s\n", selName);
return JS_FALSE;
}
}
selObj = DOM_ObjectForStyleSelector(cx, sel);
*rval = OBJECT_TO_JSVAL(selObj);
return JS_TRUE;
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку