+ // | bacon is tasty, dontcha think? + // |
+ // |great comedians may not be funny in person
+ // |Hello World
` into both divs: + // | dojo.query("div").innerHTML("Hello World
"); + // example: + // assume a DOM created by this markup: + // |Hello Mars
Hello World
Hello Mars
`: + // | var message = dojo.query("div").innerHTML(); + if(arguments.length){ + return this.addContent(value, "only"); // dojo/NodeList + }else{ + return this[0].innerHTML; //String + } + }, + + /*===== + html: function(value){ + // summary: + // see the information for "innerHTML". "html" is an alias for "innerHTML", but is + // only defined if dojo/NodeList-html has not been loaded. + // description: + // An alias for the "innerHTML" method, but only defined if there is not an existing + // "html" method on dojo/NodeList. Be careful if you are working in an environment + // where it is possible that dojo/NodeList-html could have been loaded, since its + // definition of "html" will take precedence. If you are not sure if dojo/NodeList-html + // could be loaded, use the "innerHTML" method. + // value: String|DOMNode|NodeList? + // The HTML fragment to use as innerHTML. If value is not passed, then the innerHTML + // of the first element in this NodeList is returned. + // returns: + // if no value is passed, the result is String, the innerHTML of the first node. + // If a value is passed, the return is this dojo/NodeList + return; // dojo/NodeList|String + }, + =====*/ + + text: function(/*String*/value){ + // summary: + // allows setting the text value of each node in the NodeList, + // if there is a value passed in, otherwise, returns the text value for all the + // nodes in the NodeList in one string. + // example: + // assume a DOM created by this markup: + // | + // | + // This code inserts "Hello World" into both divs: + // | dojo.query("div").text("Hello World"); + // example: + // assume a DOM created by this markup: + // |Hello Mars today
Hello World
Hello Mars
Hello World
Hello Mars
appendHello World
appendHello Mars
+ // |Hello World
+ // Running this code: + // | dojo.query("span").appendTo("p"); + // Results in this DOM structure: + // |Hello Marsappend
+ // |Hello Worldappend
+ return this._placeMultiple(query, "last"); // dojo/NodeList + }, + + prepend: function(/*String||DOMNode||NodeList*/content){ + // summary: + // prepends the content to every node in the NodeList. + // description: + // The content will be cloned if the length of NodeList + // is greater than 1. Only the DOM nodes are cloned, not + // any attached event handlers. + // returns: + // dojo/NodeList, the nodes currently in this NodeList will be returned, + // not the appended content. + // assume a DOM created by this markup: + // |Hello Mars
Hello World
Hello Mars
Hello World
Hello Mars
+ // |Hello World
+ // Running this code: + // | dojo.query("span").prependTo("p"); + // Results in this DOM structure: + // |prependHello Mars
+ // |prependHello World
+ return this._placeMultiple(query, "first"); // dojo/NodeList + }, + + after: function(/*String||Element||NodeList*/content){ + // summary: + // Places the content after every node in the NodeList. + // description: + // The content will be cloned if the length of NodeList + // is greater than 1. Only the DOM nodes are cloned, not + // any attached event handlers. + // returns: + // dojo/NodeList, the nodes currently in this NodeList will be returned, + // not the appended content. + // example: + // assume a DOM created by this markup: + // |Hello Mars
Hello World
Hello Mars
Hello World
Hello Mars
+ // |Hello World
+ // Running this code: + // | dojo.query("span").insertAfter("p"); + // Results in this DOM structure: + // |Hello Mars
after + // |Hello World
after + return this._placeMultiple(query, "after"); // dojo/NodeList + }, + + before: function(/*String||DOMNode||NodeList*/content){ + // summary: + // Places the content before every node in the NodeList. + // description: + // The content will be cloned if the length of NodeList + // is greater than 1. Only the DOM nodes are cloned, not + // any attached event handlers. + // returns: + // dojo/NodeList, the nodes currently in this NodeList will be returned, + // not the appended content. + // example: + // assume a DOM created by this markup: + // |Hello Mars
Hello World
Hello Mars
Hello World
Hello Mars
+ // |Hello World
+ // Running this code: + // | dojo.query("span").insertBefore("p"); + // Results in this DOM structure: + // | beforeHello Mars
+ // | beforeHello World
+ return this._placeMultiple(query, "before"); // dojo/NodeList + }, + + /*===== + remove: function(simpleFilter){ + // summary: + // alias for dojo/NodeList's orphan method. Removes elements + // in this list that match the simple filter from their parents + // and returns them as a new NodeList. + // simpleFilter: String + // single-expression CSS rule. For example, ".thinger" or + // "#someId[attrName='value']" but not "div > span". In short, + // anything which does not invoke a descent to evaluate but + // can instead be used to test a single node is acceptable. + + return; // dojo/NodeList + }, + =====*/ + remove: NodeList.prototype.orphan, + + wrap: function(/*String||DOMNode*/html){ + // summary: + // Wrap each node in the NodeList with html passed to wrap. + // description: + // html will be cloned if the NodeList has more than one + // element. Only DOM nodes are cloned, not any attached + // event handlers. + // returns: + // the nodes in the current NodeList will be returned, + // not the nodes from html argument. + // example: + // assume a DOM created by this markup: + // | one + // | two + // Running this code: + // | dojo.query("b").wrap("This file is used in Dojo's back/fwd button management.
+ + diff --git a/src/main/resources/static/dojo/resources/images/dndCopy.png b/src/main/resources/static/dojo/resources/images/dndCopy.png new file mode 100644 index 0000000000000000000000000000000000000000..660ca4fb10fc1a0a26bd6235a45395031d7e634e Binary files /dev/null and b/src/main/resources/static/dojo/resources/images/dndCopy.png differ diff --git a/src/main/resources/static/dojo/resources/images/dndMove.png b/src/main/resources/static/dojo/resources/images/dndMove.png new file mode 100644 index 0000000000000000000000000000000000000000..74af29c08938f718f4238fb5c4f09f6750ae56dc Binary files /dev/null and b/src/main/resources/static/dojo/resources/images/dndMove.png differ diff --git a/src/main/resources/static/dojo/resources/images/dndNoCopy.png b/src/main/resources/static/dojo/resources/images/dndNoCopy.png new file mode 100644 index 0000000000000000000000000000000000000000..998c2f2692201457b3c310e24b13e834b5b9c4c9 Binary files /dev/null and b/src/main/resources/static/dojo/resources/images/dndNoCopy.png differ diff --git a/src/main/resources/static/dojo/resources/images/dndNoMove.png b/src/main/resources/static/dojo/resources/images/dndNoMove.png new file mode 100644 index 0000000000000000000000000000000000000000..e909173e0df652ae3585c6f9e5024749761bfc60 Binary files /dev/null and b/src/main/resources/static/dojo/resources/images/dndNoMove.png differ diff --git a/src/main/resources/static/dojo/robot.js b/src/main/resources/static/dojo/robot.js new file mode 100644 index 0000000000000000000000000000000000000000..4e5ba706a71d808ec201bf941bec4eef5a70832e --- /dev/null +++ b/src/main/resources/static/dojo/robot.js @@ -0,0 +1,170 @@ +define([ + "./_base/array", + "./dom", + "./dom-geometry", + "./_base/kernel", + "./_base/lang", + "./_base/window", + "doh/_browserRunner", + "doh/robot", + "./window" +], function(array, dom, geom, kernel, lang, win, doh, robot, winUtils){ + +kernel.experimental("dojo.robot"); + +// users who use doh+dojo get the added convenience of robot.mouseMoveAt(), +// instead of computing the absolute coordinates of their elements themselves +lang.mixin(robot, { + + _resolveNode: function(/*String||DOMNode||Function*/ n){ + if(typeof n == "function"){ + // if the user passed a function returning a node, evaluate it + n = n(); + } + return n ? dom.byId(n) : null; + }, + + _scrollIntoView: function(/*Node*/ n){ + // scrolls the passed node into view, scrolling all ancestor frames/windows as well. + // Assumes parent iframes can be made fully visible given the current browser window size + var p = null; + array.forEach(robot._getWindowChain(n), function(w){ + // get the position of the node wrt its parent window + // if it is a parent frame, its padding and border extents will get added in + var p2 = geom.position(n, false), + b = geom.getPadBorderExtents(n), + oldp = null; + // if p2 is the position of the original passed node, store the position away as p + // otherwise, node is actually an iframe. in this case, add the iframe's position wrt its parent window and also the iframe's padding and border extents + if(!p){ + p = p2; + }else{ + oldp = p; + p = {x: p.x+p2.x+b.l, + y: p.y+p2.y+b.t, + w: p.w, + h: p.h}; + + } + // scroll the parent window so that the node translated into the parent window's coordinate space is in view + winUtils.scrollIntoView(n,p); + // adjust position for the new scroll offsets + p2 = geom.position(n, false); + if(!oldp){ + p = p2; + }else{ + p = {x: oldp.x+p2.x+b.l, + y: oldp.y+p2.y+b.t, + w: p.w, + h: p.h}; + } + // get the parent iframe so it can be scrolled too + n = w.frameElement; + }); + }, + + _position: function(/*Node*/ n){ + // Returns the geom.position of the passed node wrt the passed window's viewport, + // following any parent iframes containing the node and clipping the node to each iframe. + // precondition: _scrollIntoView already called + var p = null, max = Math.max, min = Math.min; + // p: the returned position of the node + array.forEach(robot._getWindowChain(n), function(w){ + // get the position of the node wrt its parent window + // if it is a parent frame, its padding and border extents will get added in + var p2 = geom.position(n, false), b = geom.getPadBorderExtents(n); + // if p2 is the position of the original passed node, store the position away as p + // otherwise, node is actually an iframe. in this case, add the iframe's position wrt its parent window and also the iframe's padding and border extents + if(!p){ + p = p2; + }else{ + var view = winUtils.getBox(n.contentWindow.document); + p2.r = p2.x+view.w; + p2.b = p2.y+view.h; + p = {x: max(p.x+p2.x,p2.x)+b.l, // clip left edge of node wrt the iframe + y: max(p.y+p2.y,p2.y)+b.t, // top edge + r: min(p.x+p2.x+p.w,p2.r)+b.l, // right edge (to compute width) + b: min(p.y+p2.y+p.h,p2.b)+b.t}; // bottom edge (to compute height) + // save a few bytes by computing width and height from r and b + p.w = p.r-p.x; + p.h = p.b-p.y; + } + // the new node is now the old node's parent iframe + n=w.frameElement; + }); + return p; + }, + + _getWindowChain : function(/*Node*/ n){ + // Returns an array of windows starting from the passed node's parent window and ending at dojo's window + var cW = winUtils.get(n.ownerDocument); + var arr = [cW]; + var f = cW.frameElement; + return (cW == win.global || !f) ? arr : arr.concat(robot._getWindowChain(f)); + }, + + scrollIntoView : function(/*String||DOMNode||Function*/ node, /*Number, optional*/ delay){ + // summary: + // Scroll the passed node into view, if it is not. + // node: + // The id of the node, or the node itself, to move the mouse to. + // If you pass an id or a function that returns a node, the node will not be evaluated until the movement executes. + // This is useful if you need to move the mouse to an node that is not yet present. + // delay: + // Delay, in milliseconds, to wait before firing. + // The delay is a delta with respect to the previous automation call. + + robot.sequence(function(){ + robot._scrollIntoView(robot._resolveNode(node)); + }, delay); + }, + + mouseMoveAt : function(/*String||DOMNode||Function*/ node, /*Integer, optional*/ delay, /*Integer, optional*/ duration, /*Number, optional*/ offsetX, /*Number, optional*/ offsetY){ + // summary: + // Moves the mouse over the specified node at the specified relative x,y offset. + // description: + // Moves the mouse over the specified node at the specified relative x,y offset. + // If you do not specify an offset, mouseMove will default to move to the middle of the node. + // Example: to move the mouse over a ComboBox's down arrow node, call doh.mouseMoveAt(dijit.byId('setvaluetest').downArrowNode); + // node: + // The id of the node, or the node itself, to move the mouse to. + // If you pass an id or a function that returns a node, the node will not be evaluated until the movement executes. + // This is useful if you need to move the mouse to an node that is not yet present. + // delay: + // Delay, in milliseconds, to wait before firing. + // The delay is a delta with respect to the previous automation call. + // For example, the following code ends after 600ms: + // | robot.mouseClick({left:true}, 100) // first call; wait 100ms + // | robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all + // duration: + // Approximate time Robot will spend moving the mouse + // The default is 100ms. + // offsetX: + // x offset relative to the node, in pixels, to move the mouse. The default is half the node's width. + // offsetY: + // y offset relative to the node, in pixels, to move the mouse. The default is half the node's height. + + robot._assertRobot(); + + // Schedule an action to scroll the node into view, then calculate it's center point + var point = {}; + this.sequence(function(){ + node = robot._resolveNode(node); + robot._scrollIntoView(node); + var pos = robot._position(node); + if(offsetY === undefined){ + offsetX = pos.w/2; + offsetY = pos.h/2; + } + point.x = pos.x+offsetX; + point.y = pos.y+offsetY; + }, delay); + + // Schedule a bunch of actions to move the mouse from the current position to point. + // These actions won't run until after the above callback. + this.mouseMoveTo(point, 0, duration, false); + } +}); + +return robot; +}); diff --git a/src/main/resources/static/dojo/robotx.js b/src/main/resources/static/dojo/robotx.js new file mode 100644 index 0000000000000000000000000000000000000000..c376a8850dc0c07932d83d5cf85c1b98c01abc48 --- /dev/null +++ b/src/main/resources/static/dojo/robotx.js @@ -0,0 +1,171 @@ +define([ + "require", + "doh/main", + "./aspect", + "./dom-construct", + "./dom-style", + "./_base/kernel", + "./_base/lang", + "./on", + "./robot", + "./sniff", + "./_base/window" +], function(require, doh, aspect, construct, style, kernel, lang, on, robot, has, win){ + +kernel.experimental("dojo.robotx"); + +// module: +// dojo.robotx +// description: +// loads an external app into an iframe and points dojo.doc to the iframe document, allowing the robot to control it +// to use: set robotURL in djConfig to the URL you want to load +// dojo.require this file + +// The iframe containing the external app +var iframe = null; + +// On IE6/7, a firebug console will appear. Scrunch it a bit to leave room for the external test file. +kernel.config.debugHeight = kernel.config.debugHeight || 200; + + +// urlLoaded is a Deferred that will be resolved whenever the iframe passed to initRobot() finishes loading, or reloads +var urlLoaded; + +function attachIframe(url){ + // summary: + // Create iframe to load external app at specified url. Iframe gets onload handler to call onIframeLoad() + // when specified URL finishes loading, and also if the iframe loads a different URL in the future. + // returns: + // A Deferred that fires when everything has finished initializing + + require(["./domReady!"], function(){ + var emptyStyle = { + overflow: "hidden", + margin: "0px", + borderWidth: "0px", + height: "100%", + width: "100%" + }; + style.set(document.documentElement, emptyStyle); + style.set(document.body, emptyStyle); + + // Create the iframe for the external document. Put it above the firebug-lite div (if such a div exists). + // console.log("creating iframe for external document"); + iframe = document.createElement("iframe"); + iframe.setAttribute("ALLOWTRANSPARENCY","true"); + iframe.scrolling = has("ie") ? "yes" : "auto"; + var scrollRoot = document.compatMode == "BackCompat" ? document.body : document.documentElement; + var consoleHeight = (document.getElementById("firebug") || {}).offsetHeight || 0; + style.set(iframe, { + border: "0px none", + padding: "0px", + margin: "0px", + width: "100%", + height: consoleHeight ? (scrollRoot.clientHeight - consoleHeight)+"px" : "100%" + }); + iframe.src = url; + + // Code to handle load event on iframe. Seems like this should happen before setting iframe src on line above? + // Also, can't we use on() in all cases, even for old IE? + if(iframe.attachEvent !== undefined){ + iframe.attachEvent("onload", onIframeLoad); + }else{ + on(iframe, "load", onIframeLoad); + } + + construct.place(iframe, win.body(), "first"); + }); +} + +function onIframeLoad(){ + // summary: + // Load handler when iframe specified to initRobot() finishes loading, or when it reloads. + // It resolves the urlLoaded Deferred to make the rests of the tests runs. + + robot._updateDocument(); + + // If dojo is present in the test case, then at least make a best effort to wait for it to load. + // The test must handle other race conditions like initial data queries or asynchronous parses by itself. + if(iframe.contentWindow.require){ + iframe.contentWindow.require(["dojo/ready"], function(ready){ + ready(Infinity, function(){ + setTimeout(function(){ + urlLoaded.resolve(true); + }, 500); // 500ms fudge factor; otherwise focus doesn't work on IE8, see ValidationTextBox.js, TimeTextBox.js, etc. + }); + }); + }else{ + urlLoaded.resolve(true); + } +} + +lang.mixin(robot, { + _updateDocument: function(){ + // summary: + // Called every time a new page is loaded into the iframe, to setup variables + // Point dojo.global, dojo.publish, etc. to refer to iframe. + // Remove for 2.0? + + kernel.setContext(iframe.contentWindow, iframe.contentWindow.document); + + // Also set pointers inside robot, for easy access via AMD (where there is no dojo variable) + robot.window = iframe.contentWindow; + robot.doc = iframe.contentWindow.document; + + // TODO: shouldn't this wait until dojo has finished loading in the iframe? See require code in onIframeLoad(). + var win = kernel.global; + if(win.dojo){ + // allow the tests to subscribe to topics published by the iframe + kernel.publish = win.dojo.publish; + kernel.subscribe = win.dojo.subscribe; + kernel.connectPublisher = win.dojo.connectPublisher; + } + }, + + initRobot: function(/*String*/ url){ + // summary: + // Opens the application at the specified URL for testing, redirecting dojo to point to the application + // environment instead of the test environment. + // url: + // URL to open. Any of the test's dojo.doc calls (e.g. dojo.byId()), and any dijit.registry calls + // (e.g. dijit.byId()) will point to elements and widgets inside this application. + + doh.registerGroup("initialize robot", { + name: "load " + url, + timeout: 100000, // could take more than 10s so setting to 100s + runTest: function(){ + // Setup module level urlLoaded Deferred that will be resolved by onIframeLoad(), after the iframe + // has finished loading + urlLoaded = new doh.Deferred(); + attachIframe(url); + + return urlLoaded; + } + }); + }, + + waitForPageToLoad: function(/*Function*/ submitActions){ + // summary: + // Notifies DOH that the doh.robot is about to make a page change in the application it is driving, + // returning a doh.Deferred object the user should return in their runTest function as part of a DOH test. + // example: + // | runTest: function(){ + // | return waitForPageLoad(function(){ doh.robot.keyPress(keys.ENTER, 500); }); + // | } + // submitActions: + // The doh.robot will execute the actions the test passes into the submitActions argument (like clicking the submit button), + // expecting these actions to create a page change (like a form submit). + // After these actions execute and the resulting page loads, the next test will start. + + // Setup a new Deferred that onIframeLoad() will resolve when the iframe finishes loading + urlLoaded = new doh.Deferred(); + + submitActions(); + + return urlLoaded; + } + +}); + +return robot; +}); diff --git a/src/main/resources/static/dojo/router.js b/src/main/resources/static/dojo/router.js new file mode 100644 index 0000000000000000000000000000000000000000..1a0e73f043ad029fd3e64fd56379854265cc89af --- /dev/null +++ b/src/main/resources/static/dojo/router.js @@ -0,0 +1,28 @@ +define([ + "./router/RouterBase" +], function(RouterBase){ + + // module: + // dojo/router + +/*===== +return { + // summary: + // A singleton-style instance of dojo/router/RouterBase. See that + // module for specifics. + // example: + // | router.register("/widgets/:id", function(evt){ + // | // If "/widgets/3" was matched, + // | // evt.params.id === "3" + // | xhr.get({ + // | url: "/some/path/" + evt.params.id, + // | load: function(data){ + // | // ... + // | } + // | }); + // | }); +}; +=====*/ + + return new RouterBase({}); +}); diff --git a/src/main/resources/static/dojo/router/RouterBase.js b/src/main/resources/static/dojo/router/RouterBase.js new file mode 100644 index 0000000000000000000000000000000000000000..05e787324c54a3a10a7b9faa7698a158ce522824 --- /dev/null +++ b/src/main/resources/static/dojo/router/RouterBase.js @@ -0,0 +1,376 @@ +define([ + "dojo/_base/declare", + "dojo/hash", + "dojo/topic" +], function(declare, hash, topic){ + + // module: + // dojo/router/RouterBase + + // Creating a basic trim to avoid needing the full dojo/string module + // similarly to dojo/_base/lang's trim + var trim; + if(String.prototype.trim){ + trim = function(str){ return str.trim(); }; + }else{ + trim = function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); }; + } + + // Firing of routes on the route object is always the same, + // no clean way to expose this on the prototype since it's for the + // internal router objects. + function fireRoute(params, currentPath, newPath){ + var queue, isStopped, isPrevented, eventObj, callbackArgs, i, l; + + queue = this.callbackQueue; + isStopped = false; + isPrevented = false; + eventObj = { + stopImmediatePropagation: function(){ isStopped = true; }, + preventDefault: function(){ isPrevented = true; }, + oldPath: currentPath, + newPath: newPath, + params: params + }; + + callbackArgs = [eventObj]; + + if(params instanceof Array){ + callbackArgs = callbackArgs.concat(params); + }else{ + for(var key in params){ + callbackArgs.push(params[key]); + } + } + + for(i=0, l=queue.length; i+ // | ... + // | + // | + // |
+ // example: + // set an "odd" class on all odd table rows inside of the table + // `#tabular_data`, using the `>` (direct child) selector to avoid + // affecting any nested tables: + // | dojo.query("#tabular_data > tbody > tr:nth-child(odd)").addClass("odd"); + // example: + // remove all elements with the class "error" from the document + // and store them in a list: + // | var errors = dojo.query(".error").orphan(); + // example: + // add an onclick handler to every submit button in the document + // which causes the form to be sent via Ajax instead: + // | dojo.query("input[type='submit']").onclick(function(e){ + // | dojo.stopEvent(e); // prevent sending the form + // | var btn = e.target; + // | dojo.xhrPost({ + // | form: btn.form, + // | load: function(data){ + // | // replace the form with the response + // | var div = dojo.doc.createElement("div"); + // | dojo.place(div, btn.form, "after"); + // | div.innerHTML = data; + // | dojo.style(btn.form, "display", "none"); + // | } + // | }); + // | }); + + root = root || getDoc(); + + // throw the big case sensitivity switch + var od = root.ownerDocument || root; // root is either Document or a node inside the document + caseSensitive = (od.createElement("div").tagName === "div"); + + // NOTE: + // adding "true" as the 2nd argument to getQueryFunc is useful for + // testing the DOM branch without worrying about the + // behavior/performance of the QSA branch. + var r = getQueryFunc(query)(root); + + // FIXME: + // need to investigate this branch WRT #8074 and #8075 + if(r && r.nozip){ + return r; + } + return _zip(r); // dojo/NodeList + }; + query.filter = function(/*Node[]*/ nodeList, /*String*/ filter, /*String|DOMNode?*/ root){ + // summary: + // function for filtering a NodeList based on a selector, optimized for simple selectors + var tmpNodeList = [], + parts = getQueryParts(filter), + filterFunc = + (parts.length == 1 && !/[^\w#\.]/.test(filter)) ? + getSimpleFilterFunc(parts[0]) : + function(node){ + return array.indexOf(query(filter, dom.byId(root)), node) != -1; + }; + for(var x = 0, te; te = nodeList[x]; x++){ + if(filterFunc(te)){ tmpNodeList.push(te); } + } + return tmpNodeList; + }; + return query; +}); diff --git a/src/main/resources/static/dojo/selector/lite.js b/src/main/resources/static/dojo/selector/lite.js new file mode 100644 index 0000000000000000000000000000000000000000..50f1ed5e39f5257e869efdbe30c61a00ee55129f --- /dev/null +++ b/src/main/resources/static/dojo/selector/lite.js @@ -0,0 +1,283 @@ +define(["../has", "../_base/kernel"], function(has, dojo){ +"use strict"; + +var testDiv = document.createElement("div"); +var matchesSelector = testDiv.matchesSelector || testDiv.webkitMatchesSelector || testDiv.mozMatchesSelector || testDiv.msMatchesSelector || testDiv.oMatchesSelector; // IE9, WebKit, Firefox have this, but not Opera yet +var querySelectorAll = testDiv.querySelectorAll; +var unionSplit = /([^\s,](?:"(?:\\.|[^"])+"|'(?:\\.|[^'])+'|[^,])*)/g; +has.add("dom-matches-selector", !!matchesSelector); +has.add("dom-qsa", !!querySelectorAll); + +// this is a simple query engine. It has handles basic selectors, and for simple +// common selectors is extremely fast +var liteEngine = function(selector, root){ + // summary: + // A small lightweight query selector engine that implements CSS2.1 selectors + // minus pseudo-classes and the sibling combinator, plus CSS3 attribute selectors + + if(combine && selector.indexOf(',') > -1){ + return combine(selector, root); + } + // use the root's ownerDocument if provided, otherwise try to use dojo.doc. Note + // that we don't use dojo/_base/window's doc to reduce dependencies, and + // fallback to plain document if dojo.doc hasn't been defined (by dojo/_base/window). + // presumably we will have a better way to do this in 2.0 + var doc = root ? root.ownerDocument || root : dojo.doc || document, + match = (querySelectorAll ? + /^([\w]*)#([\w\-]+$)|^(\.)([\w\-\*]+$)|^(\w+$)/ : // this one only matches on simple queries where we can beat qSA with specific methods + /^([\w]*)#([\w\-]+)(?:\s+(.*))?$|(?:^|(>|.+\s+))([\w\-\*]+)(\S*$)/) // this one matches parts of the query that we can use to speed up manual filtering + .exec(selector); + root = root || doc; + if(match){ + // fast path regardless of whether or not querySelectorAll exists + if(match[2]){ + // an #id + // use dojo.byId if available as it fixes the id retrieval in IE, note that we can't use the dojo namespace in 2.0, but if there is a conditional module use, we will use that + var found = dojo.byId ? dojo.byId(match[2], doc) : doc.getElementById(match[2]); + if(!found || (match[1] && match[1] != found.tagName.toLowerCase())){ + // if there is a tag qualifer and it doesn't match, no matches + return []; + } + if(root != doc){ + // there is a root element, make sure we are a child of it + var parent = found; + while(parent != root){ + parent = parent.parentNode; + if(!parent){ + return []; + } + } + } + return match[3] ? + liteEngine(match[3], found) + : [found]; + } + if(match[3] && root.getElementsByClassName){ + // a .class + return root.getElementsByClassName(match[4]); + } + var found; + if(match[5]){ + // a tag + found = root.getElementsByTagName(match[5]); + if(match[4] || match[6]){ + selector = (match[4] || "") + match[6]; + }else{ + // that was the entirety of the query, return results + return found; + } + } + } + if(querySelectorAll){ + // qSA works strangely on Element-rooted queries + // We can work around this by specifying an extra ID on the root + // and working up from there (Thanks to Andrew Dupont for the technique) + // IE 8 doesn't work on object elements + if (root.nodeType === 1 && root.nodeName.toLowerCase() !== "object"){ + return useRoot(root, selector, root.querySelectorAll); + }else{ + // we can use the native qSA + return root.querySelectorAll(selector); + } + }else if(!found){ + // search all children and then filter + found = root.getElementsByTagName("*"); + } + // now we filter the nodes that were found using the matchesSelector + var results = []; + for(var i = 0, l = found.length; i < l; i++){ + var node = found[i]; + if(node.nodeType == 1 && jsMatchesSelector(node, selector, root)){ + // keep the nodes that match the selector + results.push(node); + } + } + return results; +}; +var useRoot = function(context, query, method){ + // this function creates a temporary id so we can do rooted qSA queries, this is taken from sizzle + var oldContext = context, + old = context.getAttribute("id"), + nid = old || "__dojo__", + hasParent = context.parentNode, + relativeHierarchySelector = /^\s*[+~]/.test(query); + + if(relativeHierarchySelector && !hasParent){ + return []; + } + if(!old){ + context.setAttribute("id", nid); + }else{ + nid = nid.replace(/'/g, "\\$&"); + } + if(relativeHierarchySelector && hasParent){ + context = context.parentNode; + } + var selectors = query.match(unionSplit); + for(var i = 0; i < selectors.length; i++){ + selectors[i] = "[id='" + nid + "'] " + selectors[i]; + } + query = selectors.join(","); + + try{ + return method.call(context, query); + }finally{ + if(!old){ + oldContext.removeAttribute("id"); + } + } +}; + +if(!has("dom-matches-selector")){ + var jsMatchesSelector = (function(){ + // a JS implementation of CSS selector matching, first we start with the various handlers + var caseFix = testDiv.tagName == "div" ? "toLowerCase" : "toUpperCase"; + var selectorTypes = { + "": function(tagName){ + tagName = tagName[caseFix](); + return function(node){ + return node.tagName == tagName; + }; + }, + ".": function(className){ + var classNameSpaced = ' ' + className + ' '; + return function(node){ + return node.className.indexOf(className) > -1 && (' ' + node.className + ' ').indexOf(classNameSpaced) > -1; + }; + }, + "#": function(id){ + return function(node){ + return node.id == id; + }; + } + }; + var attrComparators = { + "^=": function(attrValue, value){ + return attrValue.indexOf(value) == 0; + }, + "*=": function(attrValue, value){ + return attrValue.indexOf(value) > -1; + }, + "$=": function(attrValue, value){ + return attrValue.substring(attrValue.length - value.length, attrValue.length) == value; + }, + "~=": function(attrValue, value){ + return (' ' + attrValue + ' ').indexOf(' ' + value + ' ') > -1; + }, + "|=": function(attrValue, value){ + return (attrValue + '-').indexOf(value + '-') == 0; + }, + "=": function(attrValue, value){ + return attrValue == value; + }, + "": function(attrValue, value){ + return true; + } + }; + function attr(name, value, type){ + var firstChar = value.charAt(0); + if(firstChar == '"' || firstChar == "'"){ + // it is quoted, remove the quotes + value = value.slice(1, -1); + } + value = value.replace(/\\/g,''); + var comparator = attrComparators[type || ""]; + return function(node){ + var attrValue = node.getAttribute(name); + return attrValue && comparator(attrValue, value); + }; + } + function ancestor(matcher){ + return function(node, root){ + while((node = node.parentNode) != root){ + if(matcher(node, root)){ + return true; + } + } + }; + } + function parent(matcher){ + return function(node, root){ + node = node.parentNode; + return matcher ? + node != root && matcher(node, root) + : node == root; + }; + } + var cache = {}; + function and(matcher, next){ + return matcher ? + function(node, root){ + return next(node) && matcher(node, root); + } + : next; + } + return function(node, selector, root){ + // this returns true or false based on if the node matches the selector (optionally within the given root) + var matcher = cache[selector]; // check to see if we have created a matcher function for the given selector + if(!matcher){ + // create a matcher function for the given selector + // parse the selectors + if(selector.replace(/(?:\s*([> ])\s*)|(#|\.)?((?:\\.|[\w-])+)|\[\s*([\w-]+)\s*(.?=)?\s*("(?:\\.|[^"])+"|'(?:\\.|[^'])+'|(?:\\.|[^\]])*)\s*\]/g, function(t, combinator, type, value, attrName, attrType, attrValue){ + if(value){ + matcher = and(matcher, selectorTypes[type || ""](value.replace(/\\/g, ''))); + } + else if(combinator){ + matcher = (combinator == " " ? ancestor : parent)(matcher); + } + else if(attrName){ + matcher = and(matcher, attr(attrName, attrValue, attrType)); + } + return ""; + })){ + throw new Error("Syntax error in query"); + } + if(!matcher){ + return true; + } + cache[selector] = matcher; + } + // now run the matcher function on the node + return matcher(node, root); + }; + })(); +} +if(!has("dom-qsa")){ + var combine = function(selector, root){ + // combined queries + var selectors = selector.match(unionSplit); + var indexed = []; + // add all results and keep unique ones, this only runs in IE, so we take advantage + // of known IE features, particularly sourceIndex which is unique and allows us to + // order the results + for(var i = 0; i < selectors.length; i++){ + selector = new String(selectors[i].replace(/\s*$/,'')); + selector.indexOf = escape; // keep it from recursively entering combine + var results = liteEngine(selector, root); + for(var j = 0, l = results.length; j < l; j++){ + var node = results[j]; + indexed[node.sourceIndex] = node; + } + } + // now convert from a sparse array to a dense array + var totalResults = []; + for(i in indexed){ + totalResults.push(indexed[i]); + } + return totalResults; + }; +} + +liteEngine.match = matchesSelector ? function(node, selector, root){ + if(root && root.nodeType != 9){ + // doesn't support three args, use rooted id trick + return useRoot(root, selector, function(query){ + return matchesSelector.call(node, query); + }); + } + // we have a native matchesSelector, use that + return matchesSelector.call(node, selector); +} : jsMatchesSelector; // otherwise use the JS matches impl + +return liteEngine; +}); diff --git a/src/main/resources/static/dojo/sniff.js b/src/main/resources/static/dojo/sniff.js new file mode 100644 index 0000000000000000000000000000000000000000..99266d5e0dd7355821ef622a7fdea850bfc4b8fc --- /dev/null +++ b/src/main/resources/static/dojo/sniff.js @@ -0,0 +1,80 @@ +define(["./has"], function(has){ + // module: + // dojo/sniff + + /*===== + return function(){ + // summary: + // This module sets has() flags based on the current browser. + // It returns the has() function. + }; + =====*/ + + if(has("host-browser")){ + var n = navigator, + dua = n.userAgent, + dav = n.appVersion, + tv = parseFloat(dav); + + has.add("air", dua.indexOf("AdobeAIR") >= 0); + has.add("msapp", parseFloat(dua.split("MSAppHost/")[1]) || undefined); + has.add("khtml", dav.indexOf("Konqueror") >= 0 ? tv : undefined); + has.add("webkit", parseFloat(dua.split("WebKit/")[1]) || undefined); + has.add("chrome", parseFloat(dua.split("Chrome/")[1]) || undefined); + has.add("safari", dav.indexOf("Safari")>=0 && !has("chrome") ? parseFloat(dav.split("Version/")[1]) : undefined); + has.add("mac", dav.indexOf("Macintosh") >= 0); + has.add("quirks", document.compatMode == "BackCompat"); + if(dua.match(/(iPhone|iPod|iPad)/)){ + var p = RegExp.$1.replace(/P/, "p"); + var v = dua.match(/OS ([\d_]+)/) ? RegExp.$1 : "1"; + var os = parseFloat(v.replace(/_/, ".").replace(/_/g, "")); + has.add(p, os); // "iphone", "ipad" or "ipod" + has.add("ios", os); + } + has.add("android", parseFloat(dua.split("Android ")[1]) || undefined); + has.add("bb", (dua.indexOf("BlackBerry") >= 0 || dua.indexOf("BB10") >= 0) && parseFloat(dua.split("Version/")[1]) || undefined); + + has.add("svg", typeof SVGAngle !== "undefined"); + + if(!has("webkit")){ + // Opera + if(dua.indexOf("Opera") >= 0){ + // see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/ + // 9.8 has both styles; <9.8, 9.9 only old style + has.add("opera", tv >= 9.8 ? parseFloat(dua.split("Version/")[1]) || tv : tv); + } + + // Mozilla and firefox + if(dua.indexOf("Gecko") >= 0 && !has("khtml") && !has("webkit")){ + has.add("mozilla", tv); + } + if(has("mozilla")){ + //We really need to get away from this. Consider a sane isGecko approach for the future. + has.add("ff", parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined); + } + + // IE + if(document.all && !has("opera")){ + var isIE = parseFloat(dav.split("MSIE ")[1]) || undefined; + + //In cases where the page has an HTTP header or META tag with + //X-UA-Compatible, then it is in emulation mode. + //Make sure isIE reflects the desired version. + //document.documentMode of 5 means quirks mode. + //Only switch the value if documentMode's major version + //is different from isIE's major version. + var mode = document.documentMode; + if(mode && mode != 5 && Math.floor(isIE) != mode){ + isIE = mode; + } + + has.add("ie", isIE); + } + + // Wii + has.add("wii", typeof opera != "undefined" && opera.wiiremote); + } + } + + return has; +}); diff --git a/src/main/resources/static/dojo/store/Cache.js b/src/main/resources/static/dojo/store/Cache.js new file mode 100644 index 0000000000000000000000000000000000000000..66de169b15e09c1961dd1506a7f87606b53d3178 --- /dev/null +++ b/src/main/resources/static/dojo/store/Cache.js @@ -0,0 +1,146 @@ +define(["../_base/lang","../when" /*=====, "../_base/declare", "./api/Store" =====*/], +function(lang, when /*=====, declare, Store =====*/){ + +// module: +// dojo/store/Cache + +var Cache = function(masterStore, cachingStore, options){ + options = options || {}; + return lang.delegate(masterStore, { + query: function(query, directives){ + var results = masterStore.query(query, directives); + results.forEach(function(object){ + if(!options.isLoaded || options.isLoaded(object)){ + cachingStore.put(object); + } + }); + return results; + }, + // look for a queryEngine in either store + queryEngine: masterStore.queryEngine || cachingStore.queryEngine, + get: function(id, directives){ + return when(cachingStore.get(id), function(result){ + return result || when(masterStore.get(id, directives), function(result){ + if(result){ + cachingStore.put(result, {id: id}); + } + return result; + }); + }); + }, + add: function(object, directives){ + return when(masterStore.add(object, directives), function(result){ + // now put result in cache + cachingStore.add(object && typeof result == "object" ? result : object, directives); + return result; // the result from the add should be dictated by the masterStore and be unaffected by the cachingStore + }); + }, + put: function(object, directives){ + // first remove from the cache, so it is empty until we get a response from the master store + cachingStore.remove((directives && directives.id) || this.getIdentity(object)); + return when(masterStore.put(object, directives), function(result){ + // now put result in cache + cachingStore.put(object && typeof result == "object" ? result : object, directives); + return result; // the result from the put should be dictated by the masterStore and be unaffected by the cachingStore + }); + }, + remove: function(id, directives){ + return when(masterStore.remove(id, directives), function(result){ + return cachingStore.remove(id, directives); + }); + }, + evict: function(id){ + return cachingStore.remove(id); + } + }); +}; +lang.setObject("dojo.store.Cache", Cache); + +/*===== +var __CacheArgs = { + // summary: + // These are additional options for how caching is handled. + // isLoaded: Function? + // This is a function that will be called for each item in a query response to determine + // if it is cacheable. If isLoaded returns true, the item will be cached, otherwise it + // will not be cached. If isLoaded is not provided, all items will be cached. +}; + +Cache = declare(Store, { + // summary: + // The Cache store wrapper takes a master store and a caching store, + // caches data from the master into the caching store for faster + // lookup. Normally one would use a memory store for the caching + // store and a server store like JsonRest for the master store. + // example: + // | var master = new Memory(data); + // | var cacher = new Memory(); + // | var store = new Cache(master, cacher); + // + constructor: function(masterStore, cachingStore, options){ + // masterStore: + // This is the authoritative store, all uncached requests or non-safe requests will + // be made against this store. + // cachingStore: + // This is the caching store that will be used to store responses for quick access. + // Typically this should be a local store. + // options: __CacheArgs? + // These are additional options for how caching is handled. + }, + query: function(query, directives){ + // summary: + // Query the underlying master store and cache any results. + // query: Object|String + // The object or string containing query information. Dependent on the query engine used. + // directives: dojo/store/api/Store.QueryOptions? + // An optional keyword arguments object with additional parameters describing the query. + // returns: dojo/store/api/Store.QueryResults + // A QueryResults object that can be used to iterate over. + }, + get: function(id, directives){ + // summary: + // Get the object with the specific id. + // id: Number + // The identifier for the object in question. + // directives: Object? + // Any additional parameters needed to describe how the get should be performed. + // returns: dojo/store/api/Store.QueryResults + // A QueryResults object. + }, + add: function(object, directives){ + // summary: + // Add the given object to the store. + // object: Object + // The object to add to the store. + // directives: dojo/store/api/Store.AddOptions? + // Any additional parameters needed to describe how the add should be performed. + // returns: Number + // The new id for the object. + }, + put: function(object, directives){ + // summary: + // Put the object into the store (similar to an HTTP PUT). + // object: Object + // The object to put to the store. + // directives: dojo/store/api/Store.PutDirectives? + // Any additional parameters needed to describe how the put should be performed. + // returns: Number + // The new id for the object. + }, + remove: function(id){ + // summary: + // Remove the object with the specific id. + // id: Number + // The identifier for the object in question. + }, + evict: function(id){ + // summary: + // Remove the object with the given id from the underlying caching store. + // id: Number + // The identifier for the object in question. + } +}); +=====*/ + +return Cache; +}); diff --git a/src/main/resources/static/dojo/store/DataStore.js b/src/main/resources/static/dojo/store/DataStore.js new file mode 100644 index 0000000000000000000000000000000000000000..c16a8d86c69a5f545827d3364ac16ea15d3eaef6 --- /dev/null +++ b/src/main/resources/static/dojo/store/DataStore.js @@ -0,0 +1,202 @@ +define([ + "../_base/lang", "../_base/declare", "../Deferred", "../_base/array", + "./util/QueryResults", "./util/SimpleQueryEngine" /*=====, "./api/Store" =====*/ +], function(lang, declare, Deferred, array, QueryResults, SimpleQueryEngine /*=====, Store =====*/){ + +// module: +// dojo/store/DataStore + + +// No base class, but for purposes of documentation, the base class is dojo/store/api/Store +var base = null; +/*===== base = Store; =====*/ + +return declare("dojo.store.DataStore", base, { + // summary: + // This is an adapter for using Dojo Data stores with an object store consumer. + // You can provide a Dojo data store and use this adapter to interact with it through + // the Dojo object store API + + target: "", + constructor: function(options){ + // options: Object? + // This provides any configuration information that will be mixed into the store, + // including a reference to the Dojo data store under the property "store". + lang.mixin(this, options); + if(!"idProperty" in options){ + var idAttribute; + try{ + idAttribute = this.store.getIdentityAttributes(); + }catch(e){ + // some store are not requiring an item instance to give us the ID attributes + // but some other do and throw errors in that case. + } + // if no idAttribute we have implicit id + this.idProperty = (!idAttribute || !idAttributes[0]) || this.idProperty; + } + var features = this.store.getFeatures(); + // check the feature set and null out any methods that shouldn't be available + if(!features["dojo.data.api.Read"]){ + this.get = null; + } + if(!features["dojo.data.api.Identity"]){ + this.getIdentity = null; + } + if(!features["dojo.data.api.Write"]){ + this.put = this.add = null; + } + }, + // idProperty: String + // The object property to use to store the identity of the store items. + idProperty: "id", + // store: + // The object store to convert to a data store + store: null, + // queryEngine: Function + // Defines the query engine to use for querying the data store + queryEngine: SimpleQueryEngine, + + _objectConverter: function(callback){ + var store = this.store; + var idProperty = this.idProperty; + function convert(item){ + var object = {}; + var attributes = store.getAttributes(item); + for(var i = 0; i < attributes.length; i++){ + var attribute = attributes[i]; + var values = store.getValues(item, attribute); + if(values.length > 1){ + for(var j = 0; j < values.length; j++){ + var value = values[j]; + if(typeof value == 'object' && store.isItem(value)){ + values[j] = convert(value); + } + } + value = values; + }else{ + var value = store.getValue(item, attribute); + if(typeof value == 'object' && store.isItem(value)){ + value = convert(value); + } + } + object[attributes[i]] = value; + } + if(!(idProperty in object) && store.getIdentity){ + object[idProperty] = store.getIdentity(item); + } + return object; + } + return function(item){ + return callback(convert(item)); + }; + }, + get: function(id, options){ + // summary: + // Retrieves an object by it's identity. This will trigger a fetchItemByIdentity + // id: Object? + // The identity to use to lookup the object + var returnedObject, returnedError; + var deferred = new Deferred(); + this.store.fetchItemByIdentity({ + identity: id, + onItem: this._objectConverter(function(object){ + deferred.resolve(returnedObject = object); + }), + onError: function(error){ + deferred.reject(returnedError = error); + } + }); + if(returnedObject){ + // if it was returned synchronously + return returnedObject; + } + if(returnedError){ + throw returnedError; + } + return deferred.promise; + }, + put: function(object, options){ + // summary: + // Stores an object by its identity. + // object: Object + // The object to store. + // options: Object? + // Additional metadata for storing the data. Includes a reference to an id + // that the object may be stored with (i.e. { id: "foo" }). + var id = options && typeof options.id != "undefined" || this.getIdentity(object); + var store = this.store; + var idProperty = this.idProperty; + if(typeof id == "undefined"){ + store.newItem(object); + store.save(); + }else{ + store.fetchItemByIdentity({ + identity: id, + onItem: function(item){ + if(item){ + for(var i in object){ + if(i != idProperty && // don't copy id properties since they are immutable and should be omitted for implicit ids + store.getValue(item, i) != object[i]){ + store.setValue(item, i, object[i]); + } + } + }else{ + store.newItem(object); + } + store.save(); + } + }); + } + }, + remove: function(id){ + // summary: + // Deletes an object by its identity. + // id: Object + // The identity to use to delete the object + var store = this.store; + this.store.fetchItemByIdentity({ + identity: id, + onItem: function(item){ + store.deleteItem(item); + store.save(); + } + }); + }, + query: function(query, options){ + // summary: + // Queries the store for objects. + // query: Object + // The query to use for retrieving objects from the store + // options: Object? + // Optional options object as used by the underlying dojo.data Store. + // returns: dojo/store/api/Store.QueryResults + // A query results object that can be used to iterate over results. + var fetchHandle; + var deferred = new Deferred(function(){ fetchHandle.abort && fetchHandle.abort(); }); + deferred.total = new Deferred(); + var converter = this._objectConverter(function(object){return object;}); + fetchHandle = this.store.fetch(lang.mixin({ + query: query, + onBegin: function(count){ + deferred.total.resolve(count); + }, + onComplete: function(results){ + deferred.resolve(array.map(results, converter)); + }, + onError: function(error){ + deferred.reject(error); + } + }, options)); + return QueryResults(deferred); + }, + getIdentity: function(object){ + // summary: + // Fetch the identity for the given object. + // object: Object + // The data object to get the identity from. + // returns: Number + // The id of the given object. + return object[this.idProperty]; + } +}); +}); diff --git a/src/main/resources/static/dojo/store/JsonRest.js b/src/main/resources/static/dojo/store/JsonRest.js new file mode 100644 index 0000000000000000000000000000000000000000..54d1c23d080732e8a329ec425a6c65fc51068122 --- /dev/null +++ b/src/main/resources/static/dojo/store/JsonRest.js @@ -0,0 +1,198 @@ +define(["../_base/xhr", "../_base/lang", "../json", "../_base/declare", "./util/QueryResults" /*=====, "./api/Store" =====*/ +], function(xhr, lang, JSON, declare, QueryResults /*=====, Store =====*/){ + +// No base class, but for purposes of documentation, the base class is dojo/store/api/Store +var base = null; +/*===== base = Store; =====*/ + +/*===== +var __HeaderOptions = { + // headers: Object? + // Additional headers to send along with the request. + }, + __PutDirectives = declare(Store.PutDirectives, __HeaderOptions), + __QueryOptions = declare(Store.QueryOptions, __HeaderOptions); +=====*/ + +return declare("dojo.store.JsonRest", base, { + // summary: + // This is a basic store for RESTful communicating with a server through JSON + // formatted data. It implements dojo/store/api/Store. + + constructor: function(options){ + // summary: + // This is a basic store for RESTful communicating with a server through JSON + // formatted data. + // options: dojo/store/JsonRest + // This provides any configuration information that will be mixed into the store + this.headers = {}; + declare.safeMixin(this, options); + }, + + // headers: Object + // Additional headers to pass in all requests to the server. These can be overridden + // by passing additional headers to calls to the store. + headers: {}, + + // target: String + // The target base URL to use for all requests to the server. This string will be + // prepended to the id to generate the URL (relative or absolute) for requests + // sent to the server + target: "", + + // idProperty: String + // Indicates the property to use as the identity property. The values of this + // property should be unique. + idProperty: "id", + + // sortParam: String + // The query parameter to used for holding sort information. If this is omitted, than + // the sort information is included in a functional query token to avoid colliding + // with the set of name/value pairs. + + // ascendingPrefix: String + // The prefix to apply to sort attribute names that are ascending + ascendingPrefix: "+", + + // descendingPrefix: String + // The prefix to apply to sort attribute names that are ascending + descendingPrefix: "-", + + + get: function(id, options){ + // summary: + // Retrieves an object by its identity. This will trigger a GET request to the server using + // the url `this.target + id`. + // id: Number + // The identity to use to lookup the object + // options: Object? + // HTTP headers. For consistency with other methods, if a `headers` key exists on this object, it will be + // used to provide HTTP headers instead. + // returns: Object + // The object in the store that matches the given id. + options = options || {}; + var headers = lang.mixin({ Accept: this.accepts }, this.headers, options.headers || options); + return xhr("GET", { + url: this.target + id, + handleAs: "json", + headers: headers + }); + }, + + // accepts: String + // Defines the Accept header to use on HTTP requests + accepts: "application/javascript, application/json", + + getIdentity: function(object){ + // summary: + // Returns an object's identity + // object: Object + // The object to get the identity from + // returns: Number + return object[this.idProperty]; + }, + + put: function(object, options){ + // summary: + // Stores an object. This will trigger a PUT request to the server + // if the object has an id, otherwise it will trigger a POST request. + // object: Object + // The object to store. + // options: __PutDirectives? + // Additional metadata for storing the data. Includes an "id" + // property if a specific id is to be used. + // returns: dojo/_base/Deferred + options = options || {}; + var id = ("id" in options) ? options.id : this.getIdentity(object); + var hasId = typeof id != "undefined"; + return xhr(hasId && !options.incremental ? "PUT" : "POST", { + url: hasId ? this.target + id : this.target, + postData: JSON.stringify(object), + handleAs: "json", + headers: lang.mixin({ + "Content-Type": "application/json", + Accept: this.accepts, + "If-Match": options.overwrite === true ? "*" : null, + "If-None-Match": options.overwrite === false ? "*" : null + }, this.headers, options.headers) + }); + }, + + add: function(object, options){ + // summary: + // Adds an object. This will trigger a PUT request to the server + // if the object has an id, otherwise it will trigger a POST request. + // object: Object + // The object to store. + // options: __PutDirectives? + // Additional metadata for storing the data. Includes an "id" + // property if a specific id is to be used. + options = options || {}; + options.overwrite = false; + return this.put(object, options); + }, + + remove: function(id, options){ + // summary: + // Deletes an object by its identity. This will trigger a DELETE request to the server. + // id: Number + // The identity to use to delete the object + // options: __HeaderOptions? + // HTTP headers. + options = options || {}; + return xhr("DELETE", { + url: this.target + id, + headers: lang.mixin({}, this.headers, options.headers) + }); + }, + + query: function(query, options){ + // summary: + // Queries the store for objects. This will trigger a GET request to the server, with the + // query added as a query string. + // query: Object + // The query to use for retrieving objects from the store. + // options: __QueryOptions? + // The optional arguments to apply to the resultset. + // returns: dojo/store/api/Store.QueryResults + // The results of the query, extended with iterative methods. + options = options || {}; + + var headers = lang.mixin({ Accept: this.accepts }, this.headers, options.headers); + + if(options.start >= 0 || options.count >= 0){ + headers.Range = headers["X-Range"] //set X-Range for Opera since it blocks "Range" header + = "items=" + (options.start || '0') + '-' + + (("count" in options && options.count != Infinity) ? + (options.count + (options.start || 0) - 1) : ''); + } + var hasQuestionMark = this.target.indexOf("?") > -1; + if(query && typeof query == "object"){ + query = xhr.objectToQuery(query); + query = query ? (hasQuestionMark ? "&" : "?") + query: ""; + } + if(options && options.sort){ + var sortParam = this.sortParam; + query += (query || hasQuestionMark ? "&" : "?") + (sortParam ? sortParam + '=' : "sort("); + for(var i = 0; ihithere
++ Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean semper + sagittis velit. Cras in mi. Duis porta mauris ut ligula. Proin porta + rutrum lacus. Etiam consequat scelerisque quam. Nulla facilisi. + Maecenas luctus venenatis nulla. In sit amet dui non mi semper iaculis. + Sed molestie tortor at ipsum. Morbi dictum rutrum magna. Sed vitae + risus. +
++ Aliquam vitae enim. Duis scelerisque metus auctor est venenatis + imperdiet. Fusce dignissim porta augue. Nulla vestibulum. Integer lorem + nunc, ullamcorper a, commodo ac, malesuada sed, dolor. Aenean id mi in + massa bibendum suscipit. Integer eros. Nullam suscipit mauris. In + pellentesque. Mauris ipsum est, pharetra semper, pharetra in, viverra + quis, tellus. Etiam purus. Quisque egestas, tortor ac cursus lacinia, + felis leo adipiscing nisi, et rhoncus elit dolor eget eros. Fusce ut + quam. Suspendisse eleifend leo vitae ligula. Nulla facilisi. Nulla + rutrum, erat vitae lacinia dictum, pede purus imperdiet lacus, ut + semper velit ante id metus. Praesent massa dolor, porttitor sed, + pulvinar in, consequat ut, leo. Nullam nec est. Aenean id risus blandit + tortor pharetra congue. Suspendisse pulvinar. +
++ Aliquam vitae enim. Duis scelerisque metus auctor est venenatis + imperdiet. Fusce dignissim porta augue. Nulla vestibulum. Integer lorem + nunc, ullamcorper a, commodo ac, malesuada sed, dolor. Aenean id mi in + massa bibendum suscipit. Integer eros. Nullam suscipit mauris. In + pellentesque. Mauris ipsum est, pharetra semper, pharetra in, viverra + quis, tellus. Etiam purus. Quisque egestas, tortor ac cursus lacinia, + felis leo adipiscing nisi, et rhoncus elit dolor eget eros. Fusce ut + quam. Suspendisse eleifend leo vitae ligula. Nulla facilisi. Nulla + rutrum, erat vitae lacinia dictum, pede purus imperdiet lacus, ut + semper velit ante id metus. Praesent massa dolor, porttitor sed, + pulvinar in, consequat ut, leo. Nullam nec est. Aenean id risus blandit + tortor pharetra congue. Suspendisse pulvinar. +
+ + + diff --git a/src/main/resources/static/dojo/tests/NodeList-manipulate.html b/src/main/resources/static/dojo/tests/NodeList-manipulate.html new file mode 100644 index 0000000000000000000000000000000000000000..f1429f9de7a3fb01aa9c3cf22be1aa71c1fa2667 --- /dev/null +++ b/src/main/resources/static/dojo/tests/NodeList-manipulate.html @@ -0,0 +1,375 @@ + + + ++ Test for dojo.connect()'s deprecated code to normalize onkeypress/onkeydown events to behave like mozilla. +
++ Type into <input>, and watch console for log messages. +
+ + +