mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-01 06:35:42 +00:00
396 lines
11 KiB
C
396 lines
11 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 Element implementation.
|
|
*/
|
|
|
|
#include "dom_priv.h"
|
|
|
|
static JSPropertySpec element_props[] = {
|
|
{"tagName", DOM_ELEMENT_TAGNAME, JSPROP_READONLY, 0, 0},
|
|
{0}
|
|
};
|
|
|
|
static JSBool
|
|
element_getter(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
|
|
{
|
|
intN slot;
|
|
DOM_Element *element;
|
|
|
|
if (!JSVAL_IS_INT(id))
|
|
return JS_TRUE;
|
|
|
|
slot = JSVAL_TO_INT(id);
|
|
|
|
/*
|
|
* Look, ma! Inheritance!
|
|
* We handle .attributes ourselves because we return something other
|
|
* than null, unlike every other Node subclass.
|
|
*/
|
|
if (slot != DOM_NODE_ATTRIBUTES &&
|
|
slot <= DOM_NODE_NODENAME &&
|
|
slot >= DOM_NODE_HASCHILDNODES) {
|
|
return dom_node_getter(cx, obj, id, vp);
|
|
}
|
|
|
|
element = (DOM_Element *)JS_GetPrivate(cx, obj);
|
|
if (!element)
|
|
return JS_TRUE;
|
|
|
|
if (slot == DOM_ELEMENT_TAGNAME) {
|
|
JSString *tagName;
|
|
#ifdef DEBUG_shaver_0
|
|
fprintf(stderr, "getting tagName %s",
|
|
element->tagName ? element->tagName : "#tag");
|
|
tagName = JS_InternString(cx, element->tagName ?
|
|
element->tagName : "#tag");
|
|
fprintf(stderr, ": %x\n", tagName);
|
|
#else
|
|
tagName = JS_NewStringCopyZ(cx, element->tagName
|
|
? element->tagName
|
|
: "#tag");
|
|
#endif
|
|
if (!tagName)
|
|
return JS_FALSE;
|
|
*vp = STRING_TO_JSVAL(tagName);
|
|
}
|
|
|
|
return JS_TRUE;
|
|
}
|
|
|
|
static JSBool
|
|
element_setter(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
|
|
{
|
|
return JS_TRUE;
|
|
}
|
|
|
|
static JSClass DOM_ElementClass = {
|
|
"Element", JSCLASS_HAS_PRIVATE,
|
|
JS_PropertyStub, JS_PropertyStub, element_getter, element_setter,
|
|
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, dom_node_finalize
|
|
};
|
|
|
|
static JSBool
|
|
element_getAttribute(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
jsval *rval)
|
|
{
|
|
DOM_Element *element;
|
|
JSString *name;
|
|
DOM_AttributeEntry *entry;
|
|
|
|
if (!JS_ConvertArguments(cx, argc, argv, "S", &name))
|
|
return JS_FALSE;
|
|
|
|
element = (DOM_Element *)JS_GetPrivate(cx, obj);
|
|
if (!element)
|
|
return JS_TRUE;
|
|
|
|
if (!DOM_GetElementAttribute(cx, element, JS_GetStringBytes(name),
|
|
&entry))
|
|
return JS_FALSE;
|
|
|
|
if (entry && entry->value) {
|
|
JSString *valstr = JS_NewStringCopyZ(cx, entry->value);
|
|
if (!valstr)
|
|
return JS_FALSE;
|
|
*rval = STRING_TO_JSVAL(valstr);
|
|
} else {
|
|
*rval = JS_GetEmptyStringValue(cx);
|
|
}
|
|
|
|
return JS_TRUE;
|
|
}
|
|
|
|
static JSBool
|
|
element_setAttribute(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
jsval *rval)
|
|
{
|
|
DOM_Element *element;
|
|
char *name, *value;
|
|
|
|
if (!JS_ConvertArguments(cx, argc, argv, "ss", &name, &value))
|
|
return JS_FALSE;
|
|
|
|
element = (DOM_Element *)JS_GetPrivate(cx, obj);
|
|
if (!element)
|
|
return JS_TRUE;
|
|
|
|
return DOM_SetElementAttribute(cx, element, name, value);
|
|
|
|
}
|
|
|
|
static JSBool
|
|
element_removeAttribute(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
jsval *rval)
|
|
{
|
|
DOM_Element *element;
|
|
JSString *name;
|
|
|
|
if (!JS_ConvertArguments(cx, argc, argv, "S", &name))
|
|
return JS_FALSE;
|
|
|
|
element = (DOM_Element *)JS_GetPrivate(cx, obj);
|
|
if (!element)
|
|
return JS_TRUE;
|
|
|
|
/* NULL setAttribute call indicates removal */
|
|
return element->ops->setAttribute(cx, element, JS_GetStringBytes(name),
|
|
NULL);
|
|
|
|
}
|
|
|
|
static JSBool
|
|
element_getAttributeNode(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
jsval *rval)
|
|
{
|
|
return JS_TRUE;
|
|
}
|
|
|
|
static JSBool
|
|
element_setAttributeNode(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
|
|
jsval *rval)
|
|
{
|
|
return JS_TRUE;
|
|
}
|
|
|
|
static JSBool
|
|
element_removeAttributeNode(JSContext *cx, JSObject *obj, uintN argc,
|
|
jsval *argv, jsval *rval)
|
|
{
|
|
return JS_TRUE;
|
|
}
|
|
|
|
static JSFunctionSpec element_methods[] = {
|
|
{"setAttribute", element_setAttribute, 2},
|
|
{"getAttribute", element_getAttribute, 1},
|
|
{"removeAttribute", element_removeAttribute, 1},
|
|
{"setAttributeNode", element_setAttributeNode, 1},
|
|
{"getAttributeNode", element_getAttributeNode, 1},
|
|
{"removeAttributeNode", element_removeAttributeNode, 1},
|
|
{0}
|
|
};
|
|
|
|
DOM_Element *
|
|
DOM_NewElement(const char *tagName, DOM_ElementOps *eleops, char *name,
|
|
char *styleClass, char *styleID, DOM_NodeOps *nodeops)
|
|
{
|
|
DOM_Node *node;
|
|
DOM_Element *element = XP_NEW_ZAP(DOM_Element);
|
|
if (!element)
|
|
return NULL;
|
|
|
|
node = (DOM_Node *)element;
|
|
node->type = NODE_TYPE_ELEMENT;
|
|
node->name = name;
|
|
node->ops = nodeops;
|
|
|
|
element->tagName = tagName;
|
|
element->styleClass = styleClass;
|
|
element->styleID = styleID;
|
|
element->ops = eleops;
|
|
|
|
return element;
|
|
}
|
|
|
|
JSObject *
|
|
DOM_NewElementObject(JSContext *cx, DOM_Element *element)
|
|
{
|
|
JSObject *obj;
|
|
|
|
obj = JS_ConstructObject(cx, &DOM_ElementClass, NULL, NULL);
|
|
if (!obj)
|
|
return NULL;
|
|
if (!JS_SetPrivate(cx, obj, element))
|
|
return NULL;
|
|
element->node.mocha_object = obj;
|
|
return obj;
|
|
}
|
|
|
|
JSObject *
|
|
DOM_ObjectForElement(JSContext *cx, DOM_Element *element)
|
|
{
|
|
if (!element)
|
|
return NULL;
|
|
if (element->node.mocha_object)
|
|
return element->node.mocha_object;
|
|
return DOM_NewElementObject(cx, element);
|
|
}
|
|
|
|
static void
|
|
DestroyAttrs(JSContext *cx, DOM_Element *element)
|
|
{
|
|
uintN i;
|
|
DOM_AttributeEntry *entry;
|
|
for (i = 0; i < element->nattrs; i++) {
|
|
entry = element->attrs + i;
|
|
if (!entry->dtor || entry->dtor(entry)) {
|
|
JS_free(cx, (char *)entry->name);
|
|
JS_free(cx, (char *)entry->value);
|
|
JS_free(cx, entry);
|
|
}
|
|
}
|
|
JS_free(cx, element->attrs);
|
|
element->attrs = NULL;
|
|
element->nattrs = 0;
|
|
}
|
|
|
|
JSBool
|
|
DOM_SetElementAttributes(JSContext *cx, DOM_Element *element,
|
|
const char **names, const char **values, uintN count)
|
|
{
|
|
DOM_AttributeEntry *entry;
|
|
uintN i;
|
|
|
|
if (element->attrs)
|
|
DestroyAttrs(cx, element);
|
|
if (!(count && names && values))
|
|
return JS_TRUE;
|
|
element->attrs =
|
|
(DOM_AttributeEntry *)JS_malloc(cx,count * sizeof(DOM_AttributeEntry));
|
|
if (!element->attrs)
|
|
return JS_FALSE;
|
|
element->nattrs = count;
|
|
|
|
#ifdef DEBUG_shaver_attributes
|
|
fprintf(stderr, "ELEMENT %p has %d attrs\n", element,
|
|
element->nattrs);
|
|
#endif
|
|
|
|
for (i = 0; i < count; i++) {
|
|
entry = element->attrs + i;
|
|
entry->name = names[i];
|
|
entry->value = values[i];
|
|
entry->dirty = entry->data = 0;
|
|
}
|
|
return JS_TRUE;
|
|
}
|
|
|
|
JSBool
|
|
DOM_GetElementAttribute(JSContext *cx, DOM_Element *element, const char *name,
|
|
DOM_AttributeEntry **entryp)
|
|
{
|
|
DOM_AttributeEntry *entry;
|
|
uintN i;
|
|
|
|
for (i = 0, entry = element->attrs;
|
|
i < element->nattrs && entry->name;
|
|
i++, entry++) {
|
|
if (!strcmp(name, entry->name)) {
|
|
*entryp = entry;
|
|
return JS_TRUE;
|
|
}
|
|
}
|
|
*entryp = NULL;
|
|
return JS_TRUE;
|
|
}
|
|
|
|
JSBool
|
|
DOM_GetCleanEntryData(JSContext *cx, DOM_AttributeEntry *entry,
|
|
DOM_DataParser parser, DOM_DataDestructor dtor,
|
|
uint32 *data, void *closure)
|
|
{
|
|
if (entry->dirty) {
|
|
uint32 newdata;
|
|
if (!parser(entry->value, &newdata, closure))
|
|
return JS_FALSE;
|
|
entry->dtor = dtor;
|
|
entry->data = newdata;
|
|
entry->dirty = JS_FALSE;
|
|
}
|
|
*data = entry->data;
|
|
return JS_TRUE;
|
|
}
|
|
|
|
static DOM_AttributeEntry *
|
|
AddAttribute(JSContext *cx, DOM_Element *element, const char *name,
|
|
const char *value)
|
|
{
|
|
DOM_AttributeEntry *entry;
|
|
|
|
if (!element->attrs) {
|
|
element->attrs = JS_malloc(cx, sizeof(DOM_AttributeEntry));
|
|
if (!element->attrs)
|
|
return NULL;
|
|
element->nattrs = 1;
|
|
} else {
|
|
element->attrs = XP_REALLOC(element->attrs,
|
|
(element->nattrs++) * sizeof(DOM_AttributeEntry));
|
|
if (!element->attrs)
|
|
return NULL;
|
|
}
|
|
entry = element->attrs + element->nattrs - 1;
|
|
entry->name = name;
|
|
entry->value = value;
|
|
#ifdef DEBUG_shaver_attributes
|
|
fprintf(stderr,
|
|
"ELEMENT %p has %d attrs after adding #%d %p/%s=%p/%s @ %p\n",
|
|
element, element->nattrs, entry - element->attrs, entry->name,
|
|
entry->name, entry->value, entry->value, entry);
|
|
#endif
|
|
return entry;
|
|
}
|
|
|
|
JSBool
|
|
dom_SetElementAttribute(JSContext *cx, DOM_Element *element, const char *name,
|
|
const char *value, JSBool runCallback)
|
|
{
|
|
DOM_AttributeEntry *entry;
|
|
if (!DOM_GetElementAttribute(cx, element, name, &entry))
|
|
return JS_FALSE;
|
|
if (!entry) {
|
|
entry = AddAttribute(cx, element, name, value);
|
|
if (!entry)
|
|
return JS_FALSE;
|
|
} else {
|
|
if (entry->value)
|
|
JS_free(cx, (char *)entry->value);
|
|
entry->value = value;
|
|
}
|
|
entry->dirty = JS_TRUE;
|
|
|
|
if (!runCallback)
|
|
return JS_TRUE;
|
|
return element->ops->setAttribute(cx, element, name, value);
|
|
}
|
|
|
|
JSBool
|
|
DOM_SetElementAttribute(JSContext *cx, DOM_Element *element, const char *name,
|
|
const char *value)
|
|
{
|
|
return dom_SetElementAttribute(cx, element, name, value, JS_TRUE);
|
|
}
|
|
|
|
static JSBool
|
|
Element(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *vp)
|
|
{
|
|
return JS_TRUE;
|
|
}
|
|
|
|
JSObject *
|
|
dom_ElementInit(JSContext *cx, JSObject *scope, JSObject *node_proto)
|
|
{
|
|
JSObject *proto = JS_InitClass(cx, scope, node_proto, &DOM_ElementClass,
|
|
Element, 0,
|
|
element_props, element_methods,
|
|
NULL, NULL);
|
|
if (!JS_DefineProperties(cx, proto, dom_node_props))
|
|
return NULL;
|
|
return proto;
|
|
}
|