Subversion Repositories Applications.papyrus

/*
        Copyright (c) 2004-2006, The Dojo Foundation
        All Rights Reserved.

        Licensed under the Academic Free License version 2.1 or above OR the
        modified BSD license. For more information on Dojo licensing, see:

                http://dojotoolkit.org/community/licensing.shtml
*/

dojo.provide("dojo.data.OpmlStore");
dojo.require("dojo.data.core.Read");
dojo.require("dojo.data.core.Result");
dojo.require("dojo.lang.assert");
dojo.require("dojo.json");
dojo.require("dojo.experimental");
dojo.experimental("dojo.data.OpmlStore");
dojo.declare("dojo.data.OpmlStore", dojo.data.core.Read, {initializer:function (keywordParameters) {
        this._arrayOfTopLevelItems = [];
        this._metadataNodes = null;
        this._loadFinished = false;
        this._opmlFileUrl = keywordParameters["url"];
}, _assertIsItem:function (item) {
        if (!this.isItem(item)) {
                throw new Error("dojo.data.OpmlStore: a function was passed an item argument that was not an item");
        }
}, _removeChildNodesThatAreNotElementNodes:function (node, recursive) {
        var childNodes = node.childNodes;
        if (childNodes.length == 0) {
                return;
        }
        var nodesToRemove = [];
        var i, childNode;
        for (i = 0; i < childNodes.length; ++i) {
                childNode = childNodes[i];
                if (childNode.nodeType != Node.ELEMENT_NODE) {
                        nodesToRemove.push(childNode);
                }
        }
        for (i = 0; i < nodesToRemove.length; ++i) {
                childNode = nodesToRemove[i];
                node.removeChild(childNode);
        }
        if (recursive) {
                for (i = 0; i < childNodes.length; ++i) {
                        childNode = childNodes[i];
                        this._removeChildNodesThatAreNotElementNodes(childNode, recursive);
                }
        }
}, _processRawXmlTree:function (rawXmlTree) {
        var headNodes = rawXmlTree.getElementsByTagName("head");
        var headNode = headNodes[0];
        this._removeChildNodesThatAreNotElementNodes(headNode);
        this._metadataNodes = headNode.childNodes;
        var bodyNodes = rawXmlTree.getElementsByTagName("body");
        var bodyNode = bodyNodes[0];
        this._removeChildNodesThatAreNotElementNodes(bodyNode, true);
        var bodyChildNodes = bodyNodes[0].childNodes;
        for (var i = 0; i < bodyChildNodes.length; ++i) {
                var node = bodyChildNodes[i];
                if (node.tagName == "outline") {
                        this._arrayOfTopLevelItems.push(node);
                }
        }
}, get:function (item, attribute, defaultValue) {
        this._assertIsItem(item);
        if (attribute == "children") {
                return (item.firstChild || defaultValue);
        } else {
                var value = item.getAttribute(attribute);
                value = (value != undefined) ? value : defaultValue;
                return value;
        }
}, getValues:function (item, attribute) {
        this._assertIsItem(item);
        if (attribute == "children") {
                var array = [];
                for (var i = 0; i < item.childNodes.length; ++i) {
                        array.push(item.childNodes[i]);
                }
                return array;
        } else {
                return [item.getAttribute(attribute)];
        }
}, getAttributes:function (item) {
        this._assertIsItem(item);
        var attributes = [];
        var xmlNode = item;
        var xmlAttributes = xmlNode.attributes;
        for (var i = 0; i < xmlAttributes.length; ++i) {
                var xmlAttribute = xmlAttributes.item(i);
                attributes.push(xmlAttribute.nodeName);
        }
        if (xmlNode.childNodes.length > 0) {
                attributes.push("children");
        }
        return attributes;
}, hasAttribute:function (item, attribute) {
        return (this.getValues(item, attribute).length > 0);
}, containsValue:function (item, attribute, value) {
        var values = this.getValues(item, attribute);
        for (var i = 0; i < values.length; ++i) {
                var possibleValue = values[i];
                if (value == possibleValue) {
                        return true;
                }
        }
        return false;
}, isItem:function (something) {
        return (something && something.nodeType == Node.ELEMENT_NODE && something.tagName == "outline");
}, isItemAvailable:function (something) {
        return this.isItem(something);
}, find:function (keywordArgs) {
        var result = null;
        if (keywordArgs instanceof dojo.data.core.Result) {
                result = keywordArgs;
                result.store = this;
        } else {
                result = new dojo.data.core.Result(keywordArgs, this);
        }
        var self = this;
        var bindHandler = function (type, data, evt) {
                var scope = result.scope || dj_global;
                if (type == "load") {
                        self._processRawXmlTree(data);
                        if (result.saveResult) {
                                result.items = self._arrayOfTopLevelItems;
                        }
                        if (result.onbegin) {
                                result.onbegin.call(scope, result);
                        }
                        for (var i = 0; i < self._arrayOfTopLevelItems.length; i++) {
                                var item = self._arrayOfTopLevelItems[i];
                                if (result.onnext && !result._aborted) {
                                        result.onnext.call(scope, item, result);
                                }
                        }
                        if (result.oncompleted && !result._aborted) {
                                result.oncompleted.call(scope, result);
                        }
                } else {
                        if (type == "error" || type == "timeout") {
                                var errorObject = data;
                                if (result.onerror) {
                                        result.onerror.call(scope, data);
                                }
                        }
                }
        };
        if (!this._loadFinished) {
                if (this._opmlFileUrl) {
                        var bindRequest = dojo.io.bind({url:this._opmlFileUrl, handle:bindHandler, mimetype:"text/xml", sync:(result.sync || false)});
                        result._abortFunc = bindRequest.abort;
                }
        }
        return result;
}, getIdentity:function (item) {
        dojo.unimplemented("dojo.data.OpmlStore.getIdentity()");
        return null;
}, findByIdentity:function (identity) {
        dojo.unimplemented("dojo.data.OpmlStore.findByIdentity()");
        return null;
}});