kjs_dom.cpp

将konqueror浏览器移植到ARM9 2410中

  if (p == "length")
    result = Number(list.length());
  else if (p == "item")
    result = new DOMNodeListFunc(list, DOMNodeListFunc::Item);
  else {
    // array index ?
    bool ok;
    long unsigned int idx = p.toULong(&ok);
    if (ok)
      result = getDOMNode(list.item(idx));
    else {
      DOM::HTMLElement e;
      unsigned long l = list.length();
      bool found = false;

      for ( unsigned long i = 0; i < l; i++ )
        if ( ( e = list.item( i ) ).id() == p.string() ) {
          result = getDOMNode( list.item( i ) );
          found = true;
          break;
        }

      if ( !found )
        result = HostImp::get(p);
    }
  }

  return result;
}

Completion DOMNodeListFunc::tryExecute(const List &args)
{
  KJSO result;

  if (id == Item)
    result = getDOMNode(list.item(args[0].toNumber().intValue()));
  return Completion(ReturnValue, result);
}

// -------------------------------------------------------------------------

const TypeInfo DOMAttr::info = { "Attr", HostType, &DOMNode::info, 0, 0 };

KJSO DOMAttr::tryGet(const UString &p) const
{
  KJSO result;
  if (p == "name") {
    result = getString(static_cast<DOM::Attr>(node).name()); }
  else if (p == "specified")
    result = Boolean(static_cast<DOM::Attr>(node).specified());
  else if (p == "value")
    result = getString(static_cast<DOM::Attr>(node).value());
//  else if (p == "ownerElement") // new for DOM2 - not yet in khtml
//    rseult = getDOMNode(static_cast<DOM::Attr>(node).ownerElement());
  else
    result = DOMNode::tryGet(p);

  return result;
}

void DOMAttr::tryPut(const UString &p, const KJSO& v)
{
  if (p == "value")
    static_cast<DOM::Attr>(node).setValue(v.toString().value().string());
  else
    DOMNode::tryPut(p,v);
}

// -------------------------------------------------------------------------

const TypeInfo DOMDocument::info = { "Document", HostType,
				     &DOMNode::info, 0, 0 };

bool DOMDocument::hasProperty(const UString &p, bool recursive) const
{
  if (p == "doctype" || p == "implementation" || p == "documentElement" ||
      p == "createElement" || p == "createDocumentFragment" ||
      p == "createTextNode" || p == "createComment" ||
      p == "createCDATASection" || p == "createProcessingInstruction" ||
      p == "createAttribute" || p == "createEntityReference" ||
      p == "getElementsByTagName" ||
      /* new for DOM2 - not yet in khtml
      p == "importNode" || p == "createElementNS" ||
      p == "createAttributeNS" || p == "getElementsByTagNameNS" ||
      p == "getElementById" ) || */
      p == "createRange" || p == "createNodeIterator" ||
      p == "createTreeWalker" || p == "defaultView" || p == "createEvent" ||
      p == "styleSheets" || p == "getOverrideStyle")
    return true;

  return recursive && DOMNode::hasProperty(p);
}

KJSO DOMDocument::tryGet(const UString &p) const
{
  DOM::Document doc = static_cast<DOM::Document>(node);

  if (p == "doctype")
    return getDOMNode(doc.doctype());
  if (p == "implementation")
    return getDOMDOMImplementation(doc.implementation());
  else if (p == "documentElement")
    return getDOMNode(doc.documentElement());
  // methods
  else if (p == "createElement")
    return new DOMDocFunction(doc, DOMDocFunction::CreateElement);
  else if (p == "createDocumentFragment")
    return new DOMDocFunction(doc, DOMDocFunction::CreateDocumentFragment);
  else if (p == "createTextNode")
    return new DOMDocFunction(doc, DOMDocFunction::CreateTextNode);
  else if (p == "createComment")
    return new DOMDocFunction(doc, DOMDocFunction::CreateComment);
  else if (p == "createCDATASection")
    return new DOMDocFunction(doc, DOMDocFunction::CreateCDATASection);
  else if (p == "createProcessingInstruction")
    return new DOMDocFunction(doc, DOMDocFunction::CreateProcessingInstruction);
  else if (p == "createAttribute")
    return new DOMDocFunction(doc, DOMDocFunction::CreateAttribute);
  else if (p == "createEntityReference")
    return new DOMDocFunction(doc, DOMDocFunction::CreateEntityReference);
  else if (p == "getElementsByTagName")
    return new DOMDocFunction(doc, DOMDocFunction::GetElementsByTagName);
//  else if (p == "importNode") // new for DOM2 - not yet in khtml
//    return new DOMDocFunction(doc, DOMDocFunction::ImportNode);
  else if (p == "createElementNS") // new for DOM2 - not yet in khtml
    return new DOMDocFunction(doc, DOMDocFunction::CreateElementNS);
  else if (p == "createAttributeNS") // new for DOM2 - not yet in khtml
    return new DOMDocFunction(doc, DOMDocFunction::CreateAttributeNS);
/*  else if (p == "getElementsByTagNameNS") // new for DOM2 - not yet in khtml
    return new DOMDocFunction(doc, DOMDocFunction::GetElementsByTagNameNS);
  else if (p == "getElementById") // new for DOM2 - not yet in khtml
    return new DOMDocFunction(doc, DOMDocFunction::GetElementById);*/
  else if (p == "createRange")
    return new DOMDocFunction(doc, DOMDocFunction::CreateRange);
  else if (p == "createNodeIterator")
    return new DOMDocFunction(doc, DOMDocFunction::CreateNodeIterator);
  else if (p == "createTreeWalker")
    return new DOMDocFunction(doc, DOMDocFunction::CreateTreeWalker);
  else if (p == "defaultView")
    return getDOMAbstractView(doc.defaultView());
  else if (p == "createEvent")
    return new DOMDocFunction(doc, DOMDocFunction::CreateEvent);
  else if (p == "styleSheets")
    return getDOMStyleSheetList(doc.styleSheets());
  else if (p == "getOverrideStyle")
    return new DOMDocFunction(doc, DOMDocFunction::GetOverrideStyle);

  return DOMNode::tryGet(p);
}

DOMDocFunction::DOMDocFunction(DOM::Document d, int i)
  : doc(d), id(i)
{
}

#include <html_document.h>

Completion DOMDocFunction::tryExecute(const List &args)
{
  KJSO result;
  String str = args[0].toString();
  DOM::DOMString s = str.value().string();

  switch(id) {
  case CreateElement:
    result = getDOMNode(doc.createElement(s));
    break;
  case CreateDocumentFragment:
    result = getDOMNode(doc.createDocumentFragment());
    break;
  case CreateTextNode:
    result = getDOMNode(doc.createTextNode(s));
    break;
  case CreateComment:
    result = getDOMNode(doc.createComment(s));
    break;
  case CreateCDATASection:
    result = getDOMNode(doc.createCDATASection(s));  /* TODO: okay ? */
    break;
  case CreateProcessingInstruction:
    result = getDOMNode(doc.createProcessingInstruction(args[0].toString().value().string(),
                                                                 args[1].toString().value().string()));
    break;
  case CreateAttribute:
    result = getDOMNode(doc.createAttribute(s));
    break;
  case CreateEntityReference:
    result = getDOMNode(doc.createEntityReference(args[0].toString().value().string()));
    break;
  case GetElementsByTagName:
    result = getDOMNodeList(doc.getElementsByTagName(s));
    break;
    /* TODO */
//  case ImportNode: // new for DOM2 - not yet in khtml
  case CreateElementNS: // new for DOM2
    result = getDOMNode(doc.createElementNS(args[0].toString().value().string(),args[1].toString().value().string()));
    break;
  case CreateAttributeNS: // new for DOM2
    result = getDOMNode(doc.createAttributeNS(args[0].toString().value().string(),args[1].toString().value().string()));
    break;
/*  case GetElementsByTagNameNS: // new for DOM2 - not yet in khtml
  case GetElementById: // new for DOM2 - not yet in khtml*/
  case CreateRange:
    result = getDOMRange(doc.createRange());
    break;
  case CreateNodeIterator:
    if (args[2].isA(NullType)) {
        DOM::NodeFilter filter;
	result = getDOMNodeIterator(doc.createNodeIterator(toNode(args[0]),(long unsigned int)(args[1].toNumber().value()),
				    filter,args[3].toBoolean().value()));
    }
    else {
	DOM::CustomNodeFilter *customFilter = new JSNodeFilter(args[2]);
	DOM::NodeFilter filter = DOM::NodeFilter::createCustom(customFilter);
	result = getDOMNodeIterator(doc.createNodeIterator(toNode(args[0]),(long unsigned int)(args[1].toNumber().value()),
				    filter,args[3].toBoolean().value()));
    }
    break;
  case CreateTreeWalker:
    result = getDOMTreeWalker(doc.createTreeWalker(toNode(args[0]),(long unsigned int)(args[1].toNumber().value()),
             toNodeFilter(args[2]),args[3].toBoolean().value()));
    break;
  case CreateEvent:
    result = getDOMEvent(doc.createEvent(s));
    break;
  case GetOverrideStyle: {
      DOM::Node arg0 = toNode(args[0]);
      if (arg0.nodeType() != DOM::Node::ELEMENT_NODE)
        result = Undefined(); // throw exception?
      else
        result = getDOMCSSStyleDeclaration(doc.getOverrideStyle(static_cast<DOM::Element>(arg0),args[1].toString().value().string()));
    }
    break;
  default:
    result = Undefined();
    break;
  }

  return Completion(ReturnValue, result);
}

// -------------------------------------------------------------------------

const TypeInfo DOMElement::info = { "Element", HostType,
				    &DOMNode::info, 0, 0 };

KJSO DOMElement::tryGet(const UString &p) const
{
  DOM::Element element = static_cast<DOM::Element>(node);

  if (p == "tagName")
    return getString(element.tagName());
  else if (p == "getAttribute")
    return new DOMElementFunction(element, DOMElementFunction::GetAttribute);
  else if (p == "setAttribute")
    return new DOMElementFunction(element, DOMElementFunction::SetAttribute);
  else if (p == "removeAttribute")
    return new DOMElementFunction(element, DOMElementFunction::RemoveAttribute);
  else if (p == "getAttributeNode")
    return new DOMElementFunction(element, DOMElementFunction::GetAttributeNode);
  else if (p == "setAttributeNode")
    return new DOMElementFunction(element, DOMElementFunction::SetAttributeNode);
  else if (p == "removeAttributeNode")
    return new DOMElementFunction(element, DOMElementFunction::RemoveAttributeNode);
  else if (p == "getElementsByTagName")
    return new DOMElementFunction(element, DOMElementFunction::GetElementsByTagName);
  else if (p == "normalize") // this is moved to Node in DOM2
    return new DOMElementFunction(element, DOMElementFunction::Normalize);
  else if (p == "style")
    return getDOMCSSStyleDeclaration(element.style());
//    return new DOMCSSStyleDeclaration(element.style()));
/*  else if (p == "getAttributeNS") // new for DOM2 - not yet in khtml
    return new DOMElementFunction(element, DOMElementFunction::GetAttributeNS);
  else if (p == "setAttributeNS") // new for DOM2 - not yet in khtml
    return new DOMElementFunction(element, DOMElementFunction::SetAttributeNS);
  else if (p == "removeAttributeNS") // new for DOM2 - not yet in khtml
    return new DOMElementFunction(element, DOMElementFunction::RemoveAttributeNS);
  else if (p == "getAttributeNodeNS") // new for DOM2 - not yet in khtml
    return new DOMElementFunction(element, DOMElementFunction::GetAttributeNodeNS);
  else if (p == "setAttributeNodeNS") // new for DOM2 - not yet in khtml
    return new DOMElementFunction(element, DOMElementFunction::SetAttributeNodeNS);
  else if (p == "getElementsByTagNameNS") // new for DOM2 - not yet in khtml
    return new DOMElementFunction(element, DOMElementFunction::GetElementsByTagNameNS);
  else if (p == "hasAttribute") // new for DOM2 - not yet in khtml
    return new DOMElementFunction(element, DOMElementFunction::HasAttribute);
  else if (p == "hasAttributeNS") // new for DOM2 - not yet in khtml
    return new DOMElementFunction(element, DOMElementFunction::HasAttributeNS);*/

  else
  {
    DOM::DOMString attr = element.getAttribute( p.string() );
    // Give access to attributes
    if ( !attr.isNull() )
      return getString( attr );
    else
      return DOMNode::tryGet(p);
  }
}


DOMElementFunction::DOMElementFunction(DOM::Element e, int i)
  : element(e), id(i)
{
}

Completion DOMElementFunction::tryExecute(const List &args)
{
  KJSO result;

  switch(id) {
    case GetAttribute:
      result = String(element.getAttribute(args[0].toString().value().string()));
      break;
    case SetAttribute:
      element.setAttribute(args[0].toString().value().string(),args[1].toString().value().string());
      result = Undefined();
      break;
    case RemoveAttribute:
      element.removeAttribute(args[0].toString().value().string());
      result = Undefined();
      break;
    case GetAttributeNode:
      result = getDOMNode(element.getAttributeNode(args[0].toString().value().string()));
      break;
    case SetAttributeNode:
      result = getDOMNode(element.setAttributeNode((new DOMNode(KJS::toNode(args[0])))->toNode()));
      break;
    case RemoveAttributeNode:
      result = getDOMNode(element.removeAttributeNode((new DOMNode(KJS::toNode(args[0])))->toNode()));
      break;
    case GetElementsByTagName:
      result = getDOMNodeList(element.getElementsByTagName(args[0].toString().value().string()));
      break;
    case Normalize: {  // this is moved to Node in DOM2
        element.normalize();
        result = Undefined();
      }
      break;
/*    case GetAttributeNS: // new for DOM2 - not yet in khtml
    case SetAttributeNS: // new for DOM2 - not yet in khtml
    case RemoveAttributeNS: // new for DOM2 - not yet in khtml
    case GetAttributeNodeNS: // new for DOM2 - not yet in khtml
    case SetAttributeNodeNS: // new for DOM2 - not yet in khtml
    case GetElementsByTagNameNS: // new for DOM2 - not yet in khtml
    case HasAttribute: // new for DOM2 - not yet in khtml
    case HasAttributeNS: // new for DOM2 - not yet in khtml*/
  default:
    result = Undefined();
  }

  return Completion(ReturnValue, result);
}

// -------------------------------------------------------------------------

const TypeInfo DOMDOMImplementation::info = { "DOMImplementation", HostType, 0, 0, 0 };

DOMDOMImplementation::~DOMDOMImplementation()
{
  domImplementations.remove(implementation.handle());
}

KJSO DOMDOMImplementation::tryGet(const UString &p) const
{
  if (p == "hasFeature")
    return new DOMDOMImplementationFunction(implementation, DOMDOMImplementationFunction::HasFeature);
//  else if (p == "createDocumentType") // new for DOM2 - not yet in khtml
//    return new DOMDOMImplementationFunction(implementation, DOMDOMImplementationFunction::CreateDocumentType);
//  else if (p == "createDocument") // new for DOM2 - not yet in khtml
//    return new DOMDOMImplementationFunction(implementation, DOMDOMImplementationFunction::CreateDocument);
  else if (p == "createCSSStyleSheet")
    return new DOMDOMImplementationFunction(implementation, DOMDOMImplementationFunction::CreateCSSStyleSheet);
  else
    return HostImp::get(p);
}

DOMDOMImplementationFunction::DOMDOMImplementationFunction(DOM::DOMImplementation impl, int i)