moving trunk for module inkscape

(bzr r1)

1 files changed, 171 insertions, 0 deletions

diff --git a/src/dom/ls.idl b/src/dom/ls.idl
new file mode 100755
index 000000000..db53ab79c
--- /dev/null
+++ b/src/dom/ls.idl
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2004 World Wide Web Consortium,
+ *
+ * (Massachusetts Institute of Technology, European Research Consortium for
+ * Informatics and Mathematics, Keio University). All Rights Reserved. This
+ * work is distributed under the W3C(r) Software License [1] in the hope that
+ * it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
+ */
+
+// File: http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407/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 LSInputStream;
+
+  typedef   Object LSOutputStream;
+
+  typedef   Object LSReader;
+
+  typedef   Object LSWriter;
+
+  typedef dom::DOMString DOMString;
+  typedef dom::DOMConfiguration DOMConfiguration;
+  typedef dom::Node Node;
+  typedef dom::Document Document;
+  typedef dom::Element Element;
+
+  interface LSParser;
+  interface LSSerializer;
+  interface LSInput;
+  interface LSOutput;
+  interface LSParserFilter;
+  interface LSSerializerFilter;
+
+  exception LSException {
+    unsigned short   code;
+  };
+  // LSExceptionCode
+  const unsigned short      PARSE_ERR                      = 81;
+  const unsigned short      SERIALIZE_ERR                  = 82;
+
+
+  interface DOMImplementationLS {
+
+    // DOMImplementationLSMode
+    const unsigned short      MODE_SYNCHRONOUS               = 1;
+    const unsigned short      MODE_ASYNCHRONOUS              = 2;
+
+    LSParser           createLSParser(in unsigned short mode, 
+                                      in DOMString schemaType)
+                                        raises(dom::DOMException);
+    LSSerializer       createLSSerializer();
+    LSInput            createLSInput();
+    LSOutput           createLSOutput();
+  };
+
+  interface LSParser {
+    readonly attribute DOMConfiguration domConfig;
+             attribute LSParserFilter  filter;
+    readonly attribute boolean         async;
+    readonly attribute boolean         busy;
+    Document           parse(in LSInput input)
+                                        raises(dom::DOMException, 
+                                               LSException);
+    Document           parseURI(in DOMString uri)
+                                        raises(dom::DOMException, 
+                                               LSException);
+
+    // 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 LSInput input, 
+                                        in Node contextArg, 
+                                        in unsigned short action)
+                                        raises(dom::DOMException, 
+                                               LSException);
+    void               abort();
+  };
+
+  interface LSInput {
+    // Depending on the language binding in use,
+    // this attribute may not be available.
+             attribute LSReader        characterStream;
+             attribute LSInputStream   byteStream;
+             attribute DOMString       stringData;
+             attribute DOMString       systemId;
+             attribute DOMString       publicId;
+             attribute DOMString       baseURI;
+             attribute DOMString       encoding;
+             attribute boolean         certifiedText;
+  };
+
+  interface LSResourceResolver {
+    LSInput            resolveResource(in DOMString type, 
+                                       in DOMString namespaceURI, 
+                                       in DOMString publicId, 
+                                       in DOMString systemId, 
+                                       in DOMString baseURI);
+  };
+
+  interface LSParserFilter {
+
+    // 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 elementArg);
+    unsigned short     acceptNode(in Node nodeArg);
+    readonly attribute unsigned long   whatToShow;
+  };
+
+  interface LSSerializer {
+    readonly attribute DOMConfiguration domConfig;
+             attribute DOMString       newLine;
+             attribute LSSerializerFilter filter;
+    boolean            write(in Node nodeArg, 
+                             in LSOutput destination)
+                                        raises(LSException);
+    boolean            writeToURI(in Node nodeArg, 
+                                  in DOMString uri)
+                                        raises(LSException);
+    DOMString          writeToString(in Node nodeArg)
+                                        raises(dom::DOMException, 
+                                               LSException);
+  };
+
+  interface LSOutput {
+    // Depending on the language binding in use,
+    // this attribute may not be available.
+             attribute LSWriter        characterStream;
+             attribute LSOutputStream  byteStream;
+             attribute DOMString       systemId;
+             attribute DOMString       encoding;
+  };
+
+  interface LSProgressEvent : events::Event {
+    readonly attribute LSInput         input;
+    readonly attribute unsigned long   position;
+    readonly attribute unsigned long   totalSize;
+  };
+
+  interface LSLoadEvent : events::Event {
+    readonly attribute Document        newDocument;
+    readonly attribute LSInput         input;
+  };
+
+  interface LSSerializerFilter : traversal::NodeFilter {
+    readonly attribute unsigned long   whatToShow;
+  };
+};
+
+#endif // _LS_IDL_
+