Appendix A: IDL Definitions

// File: ls.idl

#ifndef _LS_IDL_
#define _LS_IDL_

#include "dom.idl"
#include "events.idl"
#include "traversal.idl"

#pragma prefix "dom.w3c.org"
module ls
{

  typedef   Object DOMInputStream;

  typedef   Object DOMOutputStream;

  typedef   Object DOMReader;

  typedef   Object DOMWriter;

  typedef dom::DOMString DOMString;
  typedef dom::DOMConfiguration DOMConfiguration;
  typedef dom::Node Node;
  typedef dom::Document Document;
  typedef dom::Element Element;

  interface DOMParser;
  interface DOMSerializer;
  interface DOMInput;
  interface DOMParserFilter;
  interface DOMSerializerFilter;
  interface DOMOutput;

  interface DOMImplementationLS {

    // DOMImplementationLSMode
    const unsigned short      MODE_SYNCHRONOUS               = 1;
    const unsigned short      MODE_ASYNCHRONOUS              = 2;

    DOMParser          createDOMParser(in unsigned short mode, 
                                       in DOMString schemaType)
                                        raises(dom::DOMException);
    DOMSerializer      createDOMSerializer();
    DOMInput           createDOMInput();
  };

  interface DOMParser {
    readonly attribute DOMConfiguration config;
             attribute DOMParserFilter filter;
    readonly attribute boolean         async;
    readonly attribute boolean         busy;
    Document           parse(in DOMInput is)
                                        raises(dom::DOMException);
    Document           parseURI(in DOMString uri)
                                        raises(dom::DOMException);

    // ACTION_TYPES
    const unsigned short      ACTION_APPEND_AS_CHILDREN      = 1;
    const unsigned short      ACTION_REPLACE_CHILDREN        = 2;
    const unsigned short      ACTION_INSERT_BEFORE           = 3;
    const unsigned short      ACTION_INSERT_AFTER            = 4;
    const unsigned short      ACTION_REPLACE                 = 5;

    Node               parseWithContext(in DOMInput input, 
                                        in Node context, 
                                        in unsigned short action)
                                        raises(dom::DOMException);
    void               abort();
  };

  interface DOMInput {
    // Depending on the language binding in use,
    // this attribute may not be available.
             attribute DOMReader       characterStream;
             attribute DOMInputStream  byteStream;
             attribute DOMString       stringData;
             attribute DOMString       systemId;
             attribute DOMString       encoding;
             attribute DOMString       publicId;
             attribute DOMString       baseURI;
             attribute boolean         certified;
  };

  interface DOMResourceResolver {
    DOMInput           resolveResource(in DOMString publicId, 
                                       in DOMString systemId, 
                                       in DOMString baseURI);
  };

  interface DOMParserFilter {

    // Constants returned by startElement and acceptNode
    const short               FILTER_ACCEPT                  = 1;
    const short               FILTER_REJECT                  = 2;
    const short               FILTER_SKIP                    = 3;
    const short               FILTER_INTERRUPT               = 4;

    unsigned short     startElement(in Element element);
    unsigned short     acceptNode(in Node node);
    readonly attribute unsigned long   whatToShow;
  };

  interface DOMSerializer {
    readonly attribute DOMConfiguration config;
             attribute DOMString       newLine;
             attribute DOMSerializerFilter filter;
    boolean            write(in Node node, 
                             in DOMOutput destination);
    boolean            writeURI(in Node node, 
                                in DOMString URI);
    DOMString          writeToString(in Node node)
                                        raises(dom::DOMException);
  };

  interface DOMOutput {
    // Depending on the language binding in use,
    // this attribute may not be available.
             attribute DOMWriter       characterStream;
             attribute DOMOutputStream byteStream;
             attribute DOMString       systemId;
             attribute DOMString       encoding;
  };

  interface DocumentLS {
             attribute boolean         async;
                                        // raises(dom::DOMException) on setting

    void               abort();
    boolean            load(in DOMString uri);
    boolean            loadXML(in DOMString source);
    DOMString          saveXML(in Node node)
                                        raises(dom::DOMException);
  };

  interface ElementLS {
             attribute DOMString       markupContent;
  };

  interface LSProgressEvent : events::Event {
    readonly attribute DOMInput        input;
    readonly attribute unsigned long   position;
    readonly attribute unsigned long   totalSize;
  };

  interface LSLoadEvent : events::Event {
    readonly attribute Document        newDocument;
    readonly attribute DOMInput        input;
  };

  interface DOMSerializerFilter : traversal::NodeFilter {
    readonly attribute unsigned long   whatToShow;
  };
};

#endif // _LS_IDL_